Google Git
Sign in
apache / openoffice / bab44dcac0296df22024f3f10e7997de78ed4094 / . / AOO410 / main / sw / source / ui / shells / basesh.cxx
blob: 2569f469264660b7db2b22517d224dac5f0137a7 [file] [log] [blame]
/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"
#include <sot/factory.hxx>
#include <hintids.hxx>
#include <svl/urihelper.hxx>
#include <svl/languageoptions.hxx>
#include <svx/svxids.hrc>
#include <sfx2/linkmgr.hxx>
#include <svx/htmlmode.hxx>
#include <svx/imapdlg.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/docfile.hxx>
#include <sfx2/viewfrm.hxx>
#include <sfx2/request.hxx>
#include <svl/whiter.hxx>
#include <svl/visitem.hxx>
#include <sfx2/objitem.hxx>
#include <svtools/filter.hxx>
#include <svx/gallery.hxx>
#include <editeng/langitem.hxx>
#include <svx/clipfmtitem.hxx>
#include <svx/contdlg.hxx>
#include <vcl/graph.hxx>
#include <svl/slstitm.hxx>
#include <vcl/msgbox.hxx>
#include <svl/ptitem.hxx>
#include <svl/itemiter.hxx>
#include <svl/stritem.hxx>
#include <editeng/colritem.hxx>
#include <editeng/shaditem.hxx>
#include <editeng/boxitem.hxx>
#include <svl/srchitem.hxx>
#include <editeng/ulspitem.hxx>
#include <editeng/lrspitem.hxx>
#include <editeng/brshitem.hxx>
#include <editeng/opaqitem.hxx>
#include <editeng/sizeitem.hxx>
#include <svx/flagsdef.hxx>
#include <editeng/scripttypeitem.hxx>
#include <sfx2/objface.hxx>
#include <fmturl.hxx>
#include <fmthdft.hxx>
#include <fmtclds.hxx>
#include <docsh.hxx>
#include <wrtsh.hxx>
#include <view.hxx>
#include <swmodule.hxx>
#include <swundo.hxx>
#include <fldbas.hxx>
#include <uitool.hxx>
#include <basesh.hxx>
#include <viewopt.hxx>
#include <fontcfg.hxx>
#include <docstat.hxx>
#include <usrfld.hxx>
#include <expfld.hxx>
#include <fldmgr.hxx>
#include <frmmgr.hxx>
#include <tablemgr.hxx>
#include <mdiexp.hxx>
#include <swdtflvr.hxx>
#include <pagedesc.hxx>
#include <convert.hxx>
#include <fmtcol.hxx>
#include <edtwin.hxx>
#include <tblafmt.hxx>
#include <caption.hxx>
#include <swwait.hxx>
#include <cmdid.h>
#include <globals.hrc>
#include <shells.hrc>
#include <statstr.hrc>
#include <globals.h>
#include <unotxdoc.hxx>
#include <crsskip.hxx>
#include <fmtinfmt.hxx>
#include <doc.hxx>
#include "swabstdlg.hxx"
#include "dialog.hrc"
#include "fldui.hrc"
#include "table.hrc"
#include <modcfg.hxx>
#include <instable.hxx>
#include <svx/fmshell.hxx> // for FN_XFORMS_DESIGN_MODE
#include <SwRewriter.hxx>
#include <comcore.hrc>
#include <unomid.h>
#include <svx/galleryitem.hxx>
#include <com/sun/star/gallery/GalleryItemType.hpp>
FlyMode SwBaseShell::eFrameMode = FLY_DRAG_END;
//Fuer die Erkennung der Id, die variable von Gallery mit SID_GALLERY_BG_BRUSH
//ankommt.
static sal_uInt8 nParagraphPos;
static sal_uInt8 nGraphicPos;
static sal_uInt8 nOlePos;
static sal_uInt8 nFramePos;
static sal_uInt8 nTablePos;
static sal_uInt8 nTableRowPos;
static sal_uInt8 nTableCellPos;
static sal_uInt8 nPagePos;
static sal_uInt8 nHeaderPos;
static sal_uInt8 nFooterPos;
#define SwBaseShell
#define Shadow
#include <sfx2/msg.hxx>
#include "swslots.hxx"
#define SWCONTOURDLG(rView) ( (SvxContourDlg*) ( rView.GetViewFrame()->GetChildWindow( \
SvxContourDlgChildWindow::GetChildWindowId() )-> \
GetWindow() ) )
#define SWIMAPDLG(rView) ( (SvxIMapDlg*) ( rView.GetViewFrame()->GetChildWindow( \
SvxIMapDlgChildWindow::GetChildWindowId() )-> \
GetWindow() ) )
using namespace ::com::sun::star;
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::frame;
using namespace ::com::sun::star::lang;
SFX_IMPL_INTERFACE(SwBaseShell, SfxShell, SW_RES(0))
{
SFX_CHILDWINDOW_REGISTRATION(SvxIMapDlgChildWindow::GetChildWindowId());
SFX_CHILDWINDOW_REGISTRATION(SvxContourDlgChildWindow::GetChildWindowId());
}
TYPEINIT1(SwBaseShell,SfxShell)
/*--------------------------------------------------------------------
Beschreibung: statics
--------------------------------------------------------------------*/
void lcl_UpdateIMapDlg( SwWrtShell& rSh )
{
Graphic aGrf( rSh.GetIMapGraphic() );
GraphicType nGrfType = aGrf.GetType();
void* pEditObj = GRAPHIC_NONE != nGrfType && GRAPHIC_DEFAULT != nGrfType
? rSh.GetIMapInventor() : 0;
TargetList* pList = new TargetList;
rSh.GetView().GetViewFrame()->GetTopFrame().GetTargetList(*pList);
SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL );
rSh.GetFlyFrmAttr( aSet );
const SwFmtURL &rURL = (SwFmtURL&)aSet.Get( RES_URL );
SvxIMapDlgChildWindow::UpdateIMapDlg(
aGrf, rURL.GetMap(), pList, pEditObj );
sal_uInt16 nCount = (sal_uInt16)pList->Count();
if(nCount)
for( sal_uInt16 i = nCount; i; i-- )
{
delete pList->GetObject(i-1);
}
delete pList;
}
sal_Bool lcl_UpdateContourDlg( SwWrtShell &rSh, int nSel )
{
Graphic aGraf( rSh.GetIMapGraphic() );
GraphicType nGrfType = aGraf.GetType();
sal_Bool bRet = GRAPHIC_NONE != nGrfType && GRAPHIC_DEFAULT != nGrfType;
if( bRet )
{
String aGrfName;
if ( nSel & nsSelectionType::SEL_GRF )
rSh.GetGrfNms( &aGrfName, 0 );
SvxContourDlg *pDlg = SWCONTOURDLG(rSh.GetView());
pDlg->Update( aGraf, aGrfName.Len() > 0,
rSh.GetGraphicPolygon(), rSh.GetIMapInventor() );
}
return bRet;
}
/*--------------------------------------------------------------------
Beschreibung: loeschen
--------------------------------------------------------------------*/
void SwBaseShell::ExecDelete(SfxRequest &rReq)
{
SwWrtShell &rSh = GetShell();
SwEditWin& rTmpEditWin = GetView().GetEditWin();
switch(rReq.GetSlot())
{
case SID_DELETE:
rSh.DelRight();
break;
case FN_BACKSPACE:
if( rSh.IsNoNum() )
{
rSh.SttCrsrMove();
sal_Bool bLeft = rSh.Left( CRSR_SKIP_CHARS, sal_True, 1, sal_False );
if( bLeft )
{
// JP 28.03.96: ein Backspace im Absatz ohne Nummer wird zum Delete
//rSh.SwapPam();
//rSh.DelRight( sal_False );
rSh.DelLeft();
}
else
// JP 15.07.96: wenns nicht mehr nach vorne geht, die
// Numerierung aufheben. Z.B. am Doc-/
// Rahmen-/Tabellen-/Bereichs-Anfang
rSh.DelNumRules();
rSh.EndCrsrMove();
break;
}
// ansonsten DelLeft rufen
case FN_SHIFT_BACKSPACE:
rSh.DelLeft();
break;
default:
DBG_ERROR("falscher Dispatcher");
return;
}
rReq.Done();
//#i42732# - notify the edit window that from now on we do not use the input language
rTmpEditWin.SetUseInputLanguage( sal_False );
}
/*--------------------------------------------------------------------
Beschreibung:
--------------------------------------------------------------------*/
void SwBaseShell::ExecClpbrd(SfxRequest &rReq)
{
//Achtung: Suizid gefaehrdet! Nach Paste, Paste special kann der die
//Shell zerstoert sein.
SwWrtShell &rSh = GetShell();
sal_uInt16 nId = rReq.GetSlot();
sal_Bool bIgnore = sal_False;
switch( nId )
{
case SID_CUT:
case SID_COPY:
rView.GetEditWin().FlushInBuffer();
if ( rSh.HasSelection() )
{
SwTransferable* pTransfer = new SwTransferable( rSh );
/*??*/ uno::Reference< datatransfer::XTransferable > xRef( pTransfer );
if ( nId == SID_CUT && !rSh.IsSelObjProtected(FLYPROTECT_CONTENT|FLYPROTECT_PARENT) )
pTransfer->Cut();
else
{
const sal_Bool bLockedView = rSh.IsViewLocked();
rSh.LockView( sal_True ); //lock visible section
pTransfer->Copy();
rSh.LockView( bLockedView );
}
break;
}
return;
case SID_PASTE:
{
TransferableDataHelper aDataHelper(
TransferableDataHelper::CreateFromSystemClipboard( &rSh.GetView().GetEditWin() ) );
if( aDataHelper.GetXTransferable().is()
&& SwTransferable::IsPaste( rSh, aDataHelper )
&& !rSh.CrsrInsideInputFld() )
{
// temp. Variablen, da die Shell nach dem Paste schon
// zerstoert sein kann
SwView* pView = &rView;
SwTransferable::Paste( rSh, aDataHelper );
if( rSh.IsFrmSelected() || rSh.IsObjSelected() )
rSh.EnterSelFrmMode();
pView->AttrChangedNotify( &rSh );
}
else
return;
}
break;
case SID_CLIPBOARD_FORMAT_ITEMS:
{
const SfxItemSet* pArgs = rReq.GetArgs();
const SfxPoolItem* pFmt;
if( pArgs && SFX_ITEM_SET == pArgs->GetItemState( nId, sal_False, &pFmt ) )
{
TransferableDataHelper aDataHelper(
TransferableDataHelper::CreateFromSystemClipboard(
&rSh.GetView().GetEditWin()) );
if( aDataHelper.GetXTransferable().is()
/*&& SwTransferable::IsPaste( rSh, aDataHelper )*/ )
{
// temp. Variablen, da die Shell nach dem Paste schon
// zerstoert sein kann
SwView* pView = &rView;
SwTransferable::PasteFormat( rSh, aDataHelper,
((SfxUInt32Item*)pFmt)->GetValue() );
//Done() has to be called before the shell has been removed
rReq.Done();
bIgnore = sal_True;
if( rSh.IsFrmSelected() || rSh.IsObjSelected())
rSh.EnterSelFrmMode();
pView->AttrChangedNotify( &rSh );
}
}
}
break;
case SID_PASTE_UNFORMATTED:
{
TransferableDataHelper aDataHelper(
TransferableDataHelper::CreateFromSystemClipboard( &rSh.GetView().GetEditWin()) );
if( aDataHelper.GetXTransferable().is()
&& SwTransferable::IsPaste( rSh, aDataHelper ) )
{
// temp. Variablen, da die Shell nach dem Paste schon
// zerstoert sein kann
SwView* pView = &rView;
rReq.Ignore();
bIgnore = sal_True;
int nRet = SwTransferable::PasteUnformatted( rSh, aDataHelper );
if(nRet)// && rReq.IsRecording() )
{
SfxViewFrame* pViewFrame = pView->GetViewFrame();
uno::Reference< frame::XDispatchRecorder > xRecorder =
pViewFrame->GetBindings().GetRecorder();
if(xRecorder.is()) {
SfxRequest aReq( pViewFrame, SID_CLIPBOARD_FORMAT_ITEMS );
aReq.AppendItem( SfxUInt32Item( SID_CLIPBOARD_FORMAT_ITEMS, SOT_FORMAT_STRING ) );
aReq.Done();
}
}
if (rSh.IsFrmSelected() || rSh.IsObjSelected())
rSh.EnterSelFrmMode();
pView->AttrChangedNotify( &rSh );
}
else
return;
}
break;
case SID_PASTE_SPECIAL:
{
TransferableDataHelper aDataHelper(
TransferableDataHelper::CreateFromSystemClipboard( &rSh.GetView().GetEditWin()) );
if( aDataHelper.GetXTransferable().is()
&& SwTransferable::IsPaste( rSh, aDataHelper )
&& !rSh.CrsrInsideInputFld() )
{
// temp. Variablen, da die Shell nach dem Paste schon
// zerstoert sein kann
SwView* pView = &rView;
sal_uLong nFormatId = 0;
rReq.Ignore();
bIgnore = sal_True;
int nRet = SwTransferable::PasteSpecial( rSh, aDataHelper, nFormatId );
if(nRet)// && rReq.IsRecording() )
{
SfxViewFrame* pViewFrame = pView->GetViewFrame();
uno::Reference< frame::XDispatchRecorder > xRecorder =
pViewFrame->GetBindings().GetRecorder();
if(xRecorder.is()) {
SfxRequest aReq( pViewFrame, SID_CLIPBOARD_FORMAT_ITEMS );
aReq.AppendItem( SfxUInt32Item( SID_CLIPBOARD_FORMAT_ITEMS, nFormatId ) );
aReq.Done();
}
}
if (rSh.IsFrmSelected() || rSh.IsObjSelected())
rSh.EnterSelFrmMode();
pView->AttrChangedNotify( &rSh );
}
else
return;
}
break;
default:
DBG_ERROR("falscher Dispatcher");
return;
}
if(!bIgnore)
rReq.Done();
}
/*--------------------------------------------------------------------
Beschreibung: ClipBoard-Status
--------------------------------------------------------------------*/
void SwBaseShell::StateClpbrd(SfxItemSet &rSet)
{
SwWrtShell &rSh = GetShell();
SfxWhichIter aIter(rSet);
const sal_Bool bCopy = rSh.HasSelection();
sal_uInt16 nWhich = aIter.FirstWhich();
while(nWhich)
{
switch(nWhich)
{
case SID_CUT:
if( 0 != rSh.IsSelObjProtected(FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) )
{
rSet.DisableItem( nWhich );
break;
}
case SID_COPY:
if( !bCopy )
rSet.DisableItem( nWhich );
break;
case SID_PASTE:
if( !GetView().IsPasteAllowed()
|| rSh.CrsrInsideInputFld() )
{
rSet.DisableItem( nWhich );
}
break;
case SID_PASTE_SPECIAL:
if( !GetView().IsPasteSpecialAllowed()
|| rSh.CrsrInsideInputFld() )
{
rSet.DisableItem( nWhich );
}
break;
case SID_PASTE_UNFORMATTED:
if( !GetView().IsPasteSpecialAllowed() )
{
rSet.DisableItem( nWhich );
}
break;
case SID_CLIPBOARD_FORMAT_ITEMS:
{
TransferableDataHelper aDataHelper(
TransferableDataHelper::CreateFromSystemClipboard(
&rSh.GetView().GetEditWin()) );
SvxClipboardFmtItem aFmtItem( nWhich );
SwTransferable::FillClipFmtItem( rSh, aDataHelper, aFmtItem );
rSet.Put( aFmtItem );
}
break;
}
nWhich = aIter.NextWhich();
}
}
/*--------------------------------------------------------------------
Beschreibung: Undo ausfuehren
--------------------------------------------------------------------*/
void SwBaseShell::ExecUndo(SfxRequest &rReq)
{
SwWrtShell &rSh = GetShell();
sal_uInt16 nId = rReq.GetSlot(), nCnt = 1;
const SfxItemSet* pArgs = rReq.GetArgs();
const SfxPoolItem* pItem;
if( pArgs && SFX_ITEM_SET == pArgs->GetItemState( nId, sal_False, &pItem ))
nCnt = ((SfxUInt16Item*)pItem)->GetValue();
// #i106349#: save pointer: undo/redo may delete the shell, i.e., this!
SfxViewFrame *const pViewFrame( GetView().GetViewFrame() );
switch( nId )
{
case SID_UNDO:
rSh.LockPaint();
rSh.Do( SwWrtShell::UNDO, nCnt );
rSh.UnlockPaint();
break;
case SID_REDO:
rSh.LockPaint();
rSh.Do( SwWrtShell::REDO, nCnt );
rSh.UnlockPaint();
break;
case SID_REPEAT:
rSh.Do( SwWrtShell::REPEAT );
break;
default:
DBG_ERROR("falscher Dispatcher");
}
if (pViewFrame) { pViewFrame->GetBindings().InvalidateAll(sal_False); }
}
/*--------------------------------------------------------------------
Beschreibung: Zustand Undo
--------------------------------------------------------------------*/
void SwBaseShell::StateUndo(SfxItemSet &rSet)
{
SwWrtShell &rSh = GetShell();
SfxWhichIter aIter(rSet);
sal_uInt16 nWhich = aIter.FirstWhich();
while(nWhich)
{
switch(nWhich)
{
case SID_UNDO:
{
if (rSh.GetLastUndoInfo(0, 0))
{
rSet.Put( SfxStringItem(nWhich,
rSh.GetDoString(SwWrtShell::UNDO)));
}
else
rSet.DisableItem(nWhich);
break;
}
case SID_REDO:
{
if (rSh.GetFirstRedoInfo(0))
{
rSet.Put(SfxStringItem(nWhich,
rSh.GetDoString(SwWrtShell::REDO)));
}
else
rSet.DisableItem(nWhich);
break;
}
case SID_REPEAT:
{ // Repeat nur moeglich wenn kein REDO moeglich - UI-Restriktion
if ((!rSh.GetFirstRedoInfo(0)) &&
!rSh.IsSelFrmMode() &&
(UNDO_EMPTY != rSh.GetRepeatInfo(0)))
{
rSet.Put(SfxStringItem(nWhich, rSh.GetRepeatString()));
}
else
rSet.DisableItem(nWhich);
break;
}
case SID_GETUNDOSTRINGS:
if (rSh.GetLastUndoInfo(0, 0))
{
SfxStringListItem aStrLst( nWhich );
rSh.GetDoStrings( SwWrtShell::UNDO, aStrLst );
rSet.Put( aStrLst );
}
else
rSet.DisableItem( nWhich );
break;
case SID_GETREDOSTRINGS:
if (rSh.GetFirstRedoInfo(0))
{
SfxStringListItem aStrLst( nWhich );
rSh.GetDoStrings( SwWrtShell::REDO, aStrLst );
rSet.Put( aStrLst );
}
else
rSet.DisableItem( nWhich );
break;
}
nWhich = aIter.NextWhich();
}
}
/*--------------------------------------------------------------------
Beschreibung: Slot-Id auswerten bzw. Dispatchen
--------------------------------------------------------------------*/
void SwBaseShell::Execute(SfxRequest &rReq)
{
const SfxPoolItem *pItem;
SwWrtShell &rSh = GetShell();
const SfxItemSet* pArgs = rReq.GetArgs();
sal_Bool bMore = sal_False;
sal_uInt16 nSlot = rReq.GetSlot();
switch(nSlot)
{
case FN_REPAGINATE:
{
Reference < XModel > xModel = GetView().GetDocShell()->GetModel();
Reference < XUnoTunnel > xDocTunnel ( xModel, UNO_QUERY );
SwXTextDocument *pDoc = reinterpret_cast < SwXTextDocument * > ( xDocTunnel->getSomething ( SwXTextDocument::getUnoTunnelId() ) );
pDoc->notifyRefreshListeners();
rSh.CalcLayout();
}
break;
case FN_UPDATE_FIELDS:
{
SwDocStat aDocStat;
rSh.UpdateDocStat(aDocStat);
rSh.EndAllTblBoxEdit();
rSh.ViewShell::UpdateFlds(sal_True);
if( rSh.IsCrsrInTbl() )
{
if( !rSh.IsTblComplexForChart() )
SwTableFUNC( &rSh, sal_False).UpdateChart();
rSh.ClearTblBoxCntnt();
rSh.SaveTblBoxCntnt();
}
}
break;
case FN_UPDATE_CHARTS:
{
SwWait aWait( *rView.GetDocShell(), true );
rSh.UpdateAllCharts();
}
break;
case FN_UPDATE_ALL:
{
SwView& rTempView = GetView();
rSh.EnterStdMode();
if( rSh.GetLinkManager().GetLinks().Count() )
{
rSh.StartAllAction();
rSh.GetLinkManager().UpdateAllLinks( sal_False, sal_True, sal_True );
rSh.EndAllAction();
}
SfxDispatcher &rDis = *rTempView.GetViewFrame()->GetDispatcher();
rDis.Execute( FN_UPDATE_FIELDS );
rDis.Execute( FN_UPDATE_TOX );
rDis.Execute( FN_UPDATE_CHARTS );
rSh.CalcLayout();
}
break;
case FN_UPDATE_INPUTFIELDS:
rSh.UpdateInputFlds();
break;
case FN_PREV_BOOKMARK:
rReq.SetReturnValue(SfxBoolItem( nSlot, rSh.GoPrevBookmark()));
break;
case FN_NEXT_BOOKMARK:
rReq.SetReturnValue(SfxBoolItem( nSlot, rSh.GoNextBookmark()));
break;
case FN_GOTO_NEXT_MARK:
case FN_GOTO_PREV_MARK:
{
SwFldMgr aFldMgr;
SwFieldType* pFldType = aFldMgr.GetFldType(RES_JUMPEDITFLD);
if (pFldType)
{
if (rSh.IsSelFrmMode())
{
rSh.UnSelectFrm();
rSh.LeaveSelFrmMode();
}
if (rSh.HasMark())
{
MV_KONTEXT(&rSh);
if (rSh.IsCrsrPtAtEnd())
rSh.SwapPam();
rSh.ClearMark();
rSh.EndSelect();
}
sal_Bool bRet = rSh.MoveFldType( pFldType, nSlot == FN_GOTO_NEXT_MARK );
SwField* pCurField = bRet ? rSh.GetCurFld() : 0;
if (pCurField)
rSh.ClickToField(*pCurField);
rReq.SetReturnValue(SfxBoolItem( nSlot, bRet));
}
}
break;
case FN_START_DOC_DIRECT:
case FN_END_DOC_DIRECT:
{
if (rSh.IsSelFrmMode())
{
rSh.UnSelectFrm();
rSh.LeaveSelFrmMode();
}
rSh.EnterStdMode();
nSlot == FN_START_DOC_DIRECT ?
rSh.SttEndDoc(sal_True) :
rSh.SttEndDoc(sal_False);
}
break;
case FN_GOTO_PREV_OBJ:
case FN_GOTO_NEXT_OBJ:
{
sal_Bool bSuccess = rSh.GotoObj(
nSlot == FN_GOTO_NEXT_OBJ ? sal_True : sal_False);
rReq.SetReturnValue(SfxBoolItem(nSlot, bSuccess));
if (bSuccess && !rSh.IsSelFrmMode())
{
rSh.HideCrsr();
rSh.EnterSelFrmMode();
GetView().AttrChangedNotify( &rSh );
}
}
break;
case SID_GALLERY_FORMATS:
{
SFX_ITEMSET_ARG( pArgs, pGalleryItem, SvxGalleryItem, SID_GALLERY_FORMATS, sal_False );
if ( !pGalleryItem )
break;
const int nSelType = rSh.GetSelectionType();
sal_Int8 nGalleryItemType( pGalleryItem->GetType() );
if ( (!rSh.IsSelFrmMode() || nSelType & nsSelectionType::SEL_GRF) &&
nGalleryItemType == com::sun::star::gallery::GalleryItemType::GRAPHIC )
{
SwWait aWait( *rView.GetDocShell(), true );
String aGrfName, aFltName;
const Graphic aGrf( pGalleryItem->GetGraphic() );
if( pGalleryItem->IsLink() )
{
// Verknuepft
aGrfName = pGalleryItem->GetURL();
aFltName = pGalleryItem->GetFilterName();
}
if ( nSelType & nsSelectionType::SEL_GRF )
rSh.ReRead( aGrfName, aFltName, &aGrf );
else
rSh.Insert( aGrfName, aFltName, aGrf );
GetView().GetEditWin().GrabFocus();
}
else if(!rSh.IsSelFrmMode() &&
nGalleryItemType == com::sun::star::gallery::GalleryItemType::MEDIA )
{
const SfxStringItem aMediaURLItem( SID_INSERT_AVMEDIA, pGalleryItem->GetURL() );
GetView().GetViewFrame()->GetDispatcher()->Execute( SID_INSERT_AVMEDIA, SFX_CALLMODE_SYNCHRON, &aMediaURLItem, 0L );
/*
String sURL( pGalleryItem->GetURL().GetMainURL( INetURLObject::NO_DECODE ) );
String sLabel( pGalleryItem->GetURL().getBase() );
String sTarget; // empty string!
bool bIsHTMLMode =
0 == ( HTMLMODE_ON &
::GetHtmlMode( GetView().GetDocShell() ) );
// in Writer, we insert a button which plays the
// sound. In Writer/Web, we just insert a (text) link.
if( bIsHTMLMode )
InsertURLButton( sURL, sTarget, sLabel );
else
rSh.InsertURL( SwFmtINetFmt( sURL, sTarget ), sLabel );
*/
}
}
break;
case FN_PAGE_STYLE_SET_COLS:
{
if (pArgs)
{
// aktuellen PageDescriptor ermitteln und damit den Set fuellen
const sal_uInt16 nCurIdx = rSh.GetCurPageDesc();
SwPageDesc aPageDesc(rSh.GetPageDesc(nCurIdx));
SwFrmFmt &rFmt = aPageDesc.GetMaster();
SwFmtCol aFmtCol = rFmt.GetCol();
sal_uInt16 nCount;
if(SFX_ITEM_SET == pArgs->GetItemState(nSlot))
nCount = ((SfxUInt16Item &)pArgs->Get(nSlot)).GetValue();
else
nCount = ((SfxUInt16Item &)pArgs->Get(SID_ATTR_COLUMNS)).GetValue();
sal_uInt16 nGutterWidth = DEF_GUTTER_WIDTH;
aFmtCol.Init(nCount ? nCount : 1, nGutterWidth, USHRT_MAX);
aFmtCol.SetWishWidth(USHRT_MAX);
aFmtCol.SetGutterWidth(nGutterWidth, USHRT_MAX);
rFmt.SetFmtAttr(aFmtCol);
rSh.ChgPageDesc(nCurIdx, aPageDesc);
}
else
GetView().GetViewFrame()->GetDispatcher()->Execute(FN_FORMAT_PAGE_COLUMN_DLG, sal_False);
}
break;
case FN_CONVERT_TABLE_TO_TEXT:
case FN_CONVERT_TEXT_TO_TABLE:
case FN_CONVERT_TEXT_TABLE:
{
sal_Unicode cDelim = 0;
bool bToTable = false;
if( nSlot == FN_CONVERT_TEXT_TO_TABLE ||
( nSlot == FN_CONVERT_TEXT_TABLE && 0 == rSh.GetTableFmt() ))
bToTable = true;
SwInsertTableOptions aInsTblOpts( tabopts::ALL_TBL_INS_ATTR, 1 );
SwTableAutoFmt* pTAFmt = 0;
SwTableAutoFmtTbl* pAutoFmtTbl = 0;
bool bDeleteFormat = true;
if(pArgs && SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_1, sal_True, &pItem))
{
aInsTblOpts.mnInsMode = 0;
//Delimiter
String sDelim = static_cast< const SfxStringItem* >(pItem)->GetValue();
if(sDelim.Len())
cDelim = sDelim.GetChar(0);
//AutoFormat
if(SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_2, sal_True, &pItem))
{
String sAutoFmt = static_cast< const SfxStringItem* >(pItem)->GetValue();
pAutoFmtTbl = new SwTableAutoFmtTbl;
pAutoFmtTbl->Load();
for( sal_uInt16 i = 0, nCount = pAutoFmtTbl->Count(); i < nCount; i++ )
{
SwTableAutoFmt* pFmt = (*pAutoFmtTbl)[ i ];
if( pFmt->GetName() == sAutoFmt )
{
pTAFmt = pFmt;
bDeleteFormat = false;
break;
}
}
}
//WithHeader
if(SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_3, sal_True, &pItem) &&
static_cast< const SfxBoolItem* >(pItem)->GetValue())
aInsTblOpts.mnInsMode |= tabopts::HEADLINE;
// RepeatHeaderLines
if(SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_4, sal_True, &pItem))
aInsTblOpts.mnRowsToRepeat =
(sal_uInt16)static_cast< const SfxInt16Item* >(pItem)->GetValue();
//WithBorder
if(SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_5, sal_True, &pItem) &&
static_cast< const SfxBoolItem* >(pItem)->GetValue())
aInsTblOpts.mnInsMode |= tabopts::DEFAULT_BORDER;
//DontSplitTable
if(SFX_ITEM_SET == pArgs->GetItemState( FN_PARAM_6, sal_True, &pItem) &&
!static_cast< const SfxBoolItem* >(pItem)->GetValue() )
aInsTblOpts.mnInsMode |= tabopts::SPLIT_LAYOUT;
}
else
{
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!");
AbstractSwConvertTableDlg* pDlg = pFact->CreateSwConvertTableDlg(
GetView(),DLG_CONV_TEXT_TABLE , bToTable);
DBG_ASSERT(pDlg, "Dialogdiet fail!");
if( RET_OK == pDlg->Execute() )
{
pDlg->GetValues( cDelim, aInsTblOpts, pTAFmt );
}
delete pDlg;
}
if( cDelim )
{
//Shellwechsel!
SwView& rSaveView = rView;
sal_Bool bInserted = sal_False;
//recording:
SfxViewFrame* pViewFrame = GetView().GetViewFrame();
if( SfxRequest::HasMacroRecorder(pViewFrame) )
{
SfxRequest aReq( pViewFrame, nSlot);
aReq.AppendItem( SfxStringItem( FN_PARAM_1, String(cDelim) ));
if(bToTable)
{
if(pTAFmt)
aReq.AppendItem( SfxStringItem( FN_PARAM_2, pTAFmt->GetName()));
aReq.AppendItem( SfxBoolItem ( FN_PARAM_3, 0 != (aInsTblOpts.mnInsMode & tabopts::HEADLINE)));
aReq.AppendItem( SfxInt16Item( FN_PARAM_4, (short)aInsTblOpts.mnRowsToRepeat ));
aReq.AppendItem( SfxBoolItem ( FN_PARAM_5, 0 != (aInsTblOpts.mnInsMode & tabopts::DEFAULT_BORDER) ));
aReq.AppendItem( SfxBoolItem ( FN_PARAM_6, !(aInsTblOpts.mnInsMode & tabopts::SPLIT_LAYOUT)));
}
aReq.Done();
}
if( !bToTable )
rSh.TableToText( cDelim );
else
{
bInserted = rSh.TextToTable( aInsTblOpts, cDelim, text::HoriOrientation::FULL, pTAFmt );
}
rSh.EnterStdMode();
if( bInserted )
rSaveView.AutoCaption( TABLE_CAP );
}
if(bDeleteFormat)
delete pTAFmt;
delete pAutoFmtTbl;
}
break;
case SID_STYLE_WATERCAN:
case SID_STYLE_UPDATE_BY_EXAMPLE:
case SID_STYLE_NEW_BY_EXAMPLE:
case SID_STYLE_APPLY:
{
ShellModes eMode = GetView().GetShellMode();
if ( SHELL_MODE_DRAW != eMode &&
SHELL_MODE_DRAW_CTRL != eMode &&
SHELL_MODE_DRAW_FORM != eMode &&
SHELL_MODE_DRAWTEXT != eMode &&
SHELL_MODE_BEZIER != eMode )
{
// oj #107754#
if ( SID_STYLE_WATERCAN == nSlot )
{
const sal_Bool bLockedView = rSh.IsViewLocked();
rSh.LockView( sal_True ); //lock visible section
GetView().GetDocShell()->ExecStyleSheet(rReq);
rSh.LockView( bLockedView );
}
else
// wird von der DocShell aufgezeichnet
GetView().GetDocShell()->ExecStyleSheet(rReq);
}
}
break;
case FN_ESCAPE:
GetView().ExecuteSlot(rReq);
break;
case SID_IMAP:
{
sal_uInt16 nId = SvxIMapDlgChildWindow::GetChildWindowId();
SfxViewFrame* pVFrame = GetView().GetViewFrame();
pVFrame->ToggleChildWindow( nId );
pVFrame->GetBindings().Invalidate( SID_IMAP );
if ( pVFrame->HasChildWindow( nId ) && rSh.IsFrmSelected() )
lcl_UpdateIMapDlg( rSh );
}
break;
case SID_IMAP_EXEC:
{
SvxIMapDlg* pDlg = SWIMAPDLG(GetView());
// Kontrolle, ob Zuweisung ueberhaupt sinnvoll/erlaubt
if ( rSh.IsFrmSelected() &&
pDlg->GetEditingObject() == rSh.GetIMapInventor() )
{
SfxItemSet aSet( rSh.GetAttrPool(), RES_URL, RES_URL );
rSh.GetFlyFrmAttr( aSet );
SwFmtURL aURL( (SwFmtURL&)aSet.Get( RES_URL ) );
aURL.SetMap( &pDlg->GetImageMap() );
aSet.Put( aURL );
rSh.SetFlyFrmAttr( aSet );
}
}
break;
case SID_CONTOUR_DLG:
{
sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
SfxViewFrame* pVFrame = GetView().GetViewFrame();
pVFrame->ToggleChildWindow( nId );
pVFrame->GetBindings().Invalidate( SID_CONTOUR_DLG );
int nSel = rSh.GetSelectionType();
if ( pVFrame->HasChildWindow( nId ) &&
(nSel & (nsSelectionType::SEL_GRF|nsSelectionType::SEL_OLE)) )
{
lcl_UpdateContourDlg( rSh, nSel );
}
}
break;
case SID_CONTOUR_EXEC:
{
SvxContourDlg *pDlg = SWCONTOURDLG(GetView());
// Kontrolle, ob Zuweisung ueberhaupt sinnvoll/erlaubt
int nSel = rSh.GetSelectionType();
if ( nSel & (nsSelectionType::SEL_GRF|nsSelectionType::SEL_OLE) )
{
if ( pDlg->GetEditingObject() == rSh.GetIMapInventor() )
{
rSh.StartAction();
SfxItemSet aSet( rSh.GetAttrPool(), RES_SURROUND, RES_SURROUND);
rSh.GetFlyFrmAttr( aSet );
SwFmtSurround aSur( (SwFmtSurround&)aSet.Get( RES_SURROUND ) );
if ( !aSur.IsContour() )
{
aSur.SetContour( sal_True );
if ( aSur.GetSurround() == SURROUND_NONE )
aSur.SetSurround( SURROUND_PARALLEL );
aSet.Put( aSur );
rSh.SetFlyFrmAttr( aSet );
}
const PolyPolygon aPoly( pDlg->GetPolyPolygon() );
rSh.SetGraphicPolygon( &aPoly );
if ( pDlg->IsGraphicChanged() )
rSh.ReRead( aEmptyStr, aEmptyStr, &pDlg->GetGraphic());
rSh.EndAction();
}
}
}
break;
case FN_FRAME_TO_ANCHOR:
{
rSh.GotoFlyAnchor();
rSh.EnterStdMode();
rSh.CallChgLnk();
}
break;
case FN_TOOL_ANKER:
break;
case FN_TOOL_ANKER_PAGE:
case FN_TOOL_ANKER_PARAGRAPH:
case FN_TOOL_ANKER_CHAR:
case FN_TOOL_ANKER_AT_CHAR:
case FN_TOOL_ANKER_FRAME:
{
RndStdIds eSet = nSlot == FN_TOOL_ANKER_PAGE
? FLY_AT_PAGE
: nSlot == FN_TOOL_ANKER_PARAGRAPH
? FLY_AT_PARA
: nSlot == FN_TOOL_ANKER_FRAME
? FLY_AT_FLY
: nSlot == FN_TOOL_ANKER_CHAR
? FLY_AS_CHAR
: FLY_AT_CHAR;
rSh.StartUndo();
if( rSh.IsObjSelected() )
rSh.ChgAnchor( eSet );
else if( rSh.IsFrmSelected() )
{
// Der Set beinhaltet auch VERT/HORI_ORIENT, da in FEShell::
// SetFlyFrmAttr/SetFlyFrmAnchor ggf. als Folge des Umankerns
// die Ausrichtungen veraendert werden sollen.
SfxItemSet aSet( GetPool(), RES_VERT_ORIENT, RES_ANCHOR );
SwFmtAnchor aAnc( eSet, rSh.GetPhyPageNum() );
aSet.Put( aAnc );
rSh.SetFlyFrmAttr(aSet);
}
// if new anchor is 'as char' and it is a Math object and the usual
// pre-conditions are met then align the formula to the baseline of the text
const uno::Reference < embed::XEmbeddedObject > xObj( rSh.GetOleRef() );
const bool bDoMathBaselineAlignment = xObj.is() && SotExchange::IsMath( xObj->getClassID() )
&& FLY_AS_CHAR == eSet && rSh.GetDoc()->get( IDocumentSettingAccess::MATH_BASELINE_ALIGNMENT );
if (bDoMathBaselineAlignment)
rSh.AlignFormulaToBaseline( xObj );
sal_uInt16 nHtmlMode = ::GetHtmlMode(GetView().GetDocShell());
if( nHtmlMode )
{
SfxItemSet aSet(GetPool(), RES_SURROUND, RES_HORI_ORIENT);
rSh.GetFlyFrmAttr(aSet);
const SwFmtSurround& rSurround = (const SwFmtSurround&)aSet.Get(RES_SURROUND);
const SwFmtVertOrient& rVert = (const SwFmtVertOrient&)aSet.Get(RES_VERT_ORIENT);
const SwFmtHoriOrient& rHori = (const SwFmtHoriOrient&)aSet.Get(RES_HORI_ORIENT);
sal_Int16 eVOrient = rVert.GetVertOrient();
sal_Int16 eHOrient = rHori.GetHoriOrient();
SwSurround eSurround = rSurround.GetSurround();
switch( eSet )
{
case FLY_AT_FLY:
case FLY_AT_PAGE:
//Durchlauf, links oder von links, oben, von oben
if(eSurround != SURROUND_THROUGHT)
aSet.Put(SwFmtSurround(SURROUND_THROUGHT));
if( eVOrient != text::VertOrientation::TOP && eVOrient != text::VertOrientation::NONE)
aSet.Put(SwFmtVertOrient(0, text::VertOrientation::TOP));
if(eHOrient != text::HoriOrientation::NONE || eHOrient != text::HoriOrientation::LEFT)
aSet.Put(SwFmtHoriOrient(0, text::HoriOrientation::LEFT));
break;
case FLY_AT_PARA:
//links, von links, rechts, oben, kein Uml, li+re Umlauf,
if(eSurround != SURROUND_LEFT || eSurround != SURROUND_RIGHT)
aSet.Put(SwFmtSurround(SURROUND_LEFT));
if( eVOrient != text::VertOrientation::TOP)
aSet.Put(SwFmtVertOrient(0, text::VertOrientation::TOP));
if(eHOrient != text::HoriOrientation::NONE || eHOrient != text::HoriOrientation::LEFT || eHOrient != text::HoriOrientation::RIGHT)
aSet.Put(SwFmtHoriOrient(0, text::HoriOrientation::LEFT));
break;
case FLY_AT_CHAR:
//links, von links, rechts, oben, Durchlauf
if(eSurround != SURROUND_THROUGHT)
aSet.Put(SwFmtSurround(SURROUND_THROUGHT));
if( eVOrient != text::VertOrientation::TOP)
aSet.Put(SwFmtVertOrient(0, text::VertOrientation::TOP));
if(eHOrient != text::HoriOrientation::NONE || eHOrient != text::HoriOrientation::LEFT || eHOrient != text::HoriOrientation::RIGHT)
aSet.Put(SwFmtHoriOrient(0, text::HoriOrientation::LEFT));
break;
default:
;
}
if( aSet.Count() )
rSh.SetFlyFrmAttr( aSet );
}
rSh.EndUndo();
GetView().GetViewFrame()->GetBindings().Invalidate( FN_TOOL_ANKER );
}
break;
case FN_FRAME_NOWRAP:
case FN_FRAME_WRAP:
case FN_FRAME_WRAP_IDEAL:
case FN_FRAME_WRAPTHRU:
case FN_FRAME_WRAPTHRU_TRANSP:
case FN_FRAME_WRAP_CONTOUR:
case FN_WRAP_ANCHOR_ONLY:
case FN_FRAME_WRAP_LEFT:
case FN_FRAME_WRAP_RIGHT:
SetWrapMode( nSlot );
break;
case FN_UPDATE_ALL_LINKS:
{
if( rSh.GetLinkManager().GetLinks().Count() )
{
sal_Bool bUpdateGrf = sal_False, bCallErrHdl = sal_False;
rSh.EnterStdMode();
rSh.StartAllAction();
rSh.GetLinkManager().UpdateAllLinks( sal_False, bCallErrHdl, bUpdateGrf );
rSh.EndAllAction();
}
}
break;
case FN_XFORMS_DESIGN_MODE:
if( pArgs != NULL
&& pArgs->GetItemState( nSlot, sal_True, &pItem ) == SFX_ITEM_SET
&& pItem != NULL
&& pItem->ISA( SfxBoolItem ) )
{
sal_Bool bDesignMode =
static_cast<const SfxBoolItem*>( pItem )->GetValue();
// set form design mode
DBG_ASSERT( GetView().GetFormShell() != NULL, "form shell?" );
SfxRequest aReq( GetView().GetViewFrame(), SID_FM_DESIGN_MODE );
aReq.AppendItem( SfxBoolItem( SID_FM_DESIGN_MODE, bDesignMode ) );
GetView().GetFormShell()->Execute( aReq );
aReq.Done();
// also set suitable view options
SwViewOption aViewOption = *rSh.GetViewOptions();
aViewOption.SetFormView( ! bDesignMode );
rSh.ApplyViewOptions( aViewOption );
}
break;
default:
bMore = sal_True;
}
if(bMore && pArgs)
{
pItem = 0;
pArgs->GetItemState(GetPool().GetWhich(nSlot), sal_False, &pItem);
if(pItem)
switch(nSlot)
{
case SID_ATTR_BRUSH:
case SID_ATTR_BORDER_SHADOW:
case RES_SHADOW:
{
rSh.StartAllAction();
SfxItemSet aSet( rSh.GetAttrPool(),
RES_SHADOW, RES_SHADOW,
RES_BACKGROUND, RES_BACKGROUND, 0 );
aSet.Put(*pItem);
// Tabellenzelle(n) selektiert?
if ( rSh.IsTableMode() )
{
SwFrmFmt *pFmt = rSh.GetTableFmt();
pFmt->SetFmtAttr( *pItem );
}
else if ( rSh.IsFrmSelected() )
{
// Umrandungsattribute ueber Frame-Manager setzen
SwFlyFrmAttrMgr aMgr( sal_False, &rSh, FRMMGR_TYPE_NONE );
aMgr.SetAttrSet( *pArgs );
aMgr.UpdateFlyFrm();
}
else
{
rSh.SetAttrSet( *pArgs );
}
rSh.EndAllAction();
}
break;
case FN_PAGE_STYLE_SET_LR_MARGIN:
case FN_PAGE_STYLE_SET_UL_MARGIN:
case FN_PAGE_STYLE_SET_NUMBER_FORMAT:
case FN_PAGE_STYLE_SET_PAPER_SIZE:
case FN_PAGE_STYLE_SET_PAPER_BIN:
{
DBG_ERROR("not implemented");
}
break;
case SID_ATTR_BORDER_OUTER:
{
// Tabellenzelle(n) selektiert?
if ( rSh.IsTableMode() )
{
// Umrandungattribute Get/SetTabBorders() setzen
rSh.SetTabBorders(*pArgs);
}
else if ( rSh.IsFrmSelected() )
{
// Umrandungsattribute ueber Frame-Manager setzen
SwFlyFrmAttrMgr aMgr( sal_False, &rSh, FRMMGR_TYPE_NONE );
aMgr.SetAttrSet(*pArgs);
aMgr.UpdateFlyFrm();
}
else
{
// Umrandungsattribute ganz normal ueber Shell setzen
rSh.SetAttrItem( *pItem );
}
}
break;
default:
DBG_ERROR("falscher Dispatcher");
}
}
}
/* -----------------14.04.99 15:10-------------------
* Hier wird der State fuer SID_IMAP / SID_CONTOUR behandelt,
* wenn die Grafik ausgeswappt ist
* --------------------------------------------------*/
IMPL_LINK(SwBaseShell, GraphicArrivedHdl, SwCrsrShell* , EMPTYARG )
{
sal_uInt16 nGrfType;
SwWrtShell &rSh = GetShell();
if( CNT_GRF == rSh.SwEditShell::GetCntType() &&
GRAPHIC_NONE != ( nGrfType = rSh.GetGraphicType() ) &&
aGrfUpdateSlots.Count() )
{
sal_Bool bProtect = 0 != rSh.IsSelObjProtected(FLYPROTECT_CONTENT|FLYPROTECT_PARENT);
SfxViewFrame* pVFrame = GetView().GetViewFrame();
sal_uInt16 nSlot;
for( sal_uInt16 n = 0; n < aGrfUpdateSlots.Count(); ++n )
{
sal_Bool bSetState = sal_False;
sal_Bool bState = sal_False;
switch( nSlot = aGrfUpdateSlots[ n ] )
{
case SID_IMAP:
case SID_IMAP_EXEC:
{
sal_uInt16 nId = SvxIMapDlgChildWindow::GetChildWindowId();
SvxIMapDlg *pDlg = pVFrame->HasChildWindow( nId ) ?
(SvxIMapDlg*) ( pVFrame->GetChildWindow( nId )
->GetWindow()) : 0;
if( pDlg && ( SID_IMAP_EXEC == nSlot ||
( SID_IMAP == nSlot && !bProtect)) &&
pDlg->GetEditingObject() != rSh.GetIMapInventor())
lcl_UpdateIMapDlg( rSh );
if( !bProtect && SID_IMAP == nSlot )
bSetState = sal_True, bState = 0 != pDlg;
}
break;
case SID_CONTOUR_DLG:
if( !bProtect )
{
sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
SvxIMapDlg *pDlg = pVFrame->HasChildWindow( nId ) ?
(SvxIMapDlg*) ( pVFrame->GetChildWindow( nId )
->GetWindow()) : 0;
if( pDlg && pDlg->GetEditingObject() !=
rSh.GetIMapInventor() )
lcl_UpdateContourDlg( rSh, nsSelectionType::SEL_GRF );
bSetState = sal_True;
bState = 0 != pDlg;
}
break;
case FN_FRAME_WRAP_CONTOUR:
if( !bProtect )
{
SfxItemSet aSet(GetPool(), RES_SURROUND, RES_SURROUND);
rSh.GetFlyFrmAttr(aSet);
const SwFmtSurround& rWrap = (const SwFmtSurround&)aSet.Get(RES_SURROUND);
bSetState = sal_True;
bState = rWrap.IsContour();
}
break;
case SID_GRFFILTER:
case SID_GRFFILTER_INVERT:
case SID_GRFFILTER_SMOOTH:
case SID_GRFFILTER_SHARPEN:
case SID_GRFFILTER_REMOVENOISE:
case SID_GRFFILTER_SOBEL:
case SID_GRFFILTER_MOSAIC:
case SID_GRFFILTER_EMBOSS:
case SID_GRFFILTER_POSTER:
case SID_GRFFILTER_POPART:
case SID_GRFFILTER_SEPIA:
case SID_GRFFILTER_SOLARIZE:
bSetState = bState = GRAPHIC_BITMAP == nGrfType;
break;
}
if( bSetState )
{
SfxBoolItem aBool( nSlot, bState );
if( pGetStateSet )
pGetStateSet->Put( aBool );
else
pVFrame->GetBindings().SetState( aBool );
}
}
aGrfUpdateSlots.RemoveAt( 0, aGrfUpdateSlots.Count() );
}
return 0;
}
void SwBaseShell::GetState( SfxItemSet &rSet )
{
SwWrtShell &rSh = GetShell();
SfxViewFrame* pVFrame = GetView().GetViewFrame();
SfxWhichIter aIter( rSet );
sal_uInt16 nWhich = aIter.FirstWhich();
pGetStateSet = &rSet;
while ( nWhich )
{
switch ( nWhich )
{
case SID_GALLERY_FORMATS:
if ( rSh.IsObjSelected() ||
(rSh.IsSelFrmMode() &&
!(rSh.GetSelectionType() & nsSelectionType::SEL_GRF)) )
rSet.DisableItem( nWhich );
break;
case SID_GALLERY_ENABLE_ADDCOPY:
// #108230# allow copy from gallery in Writer AND Writer/Web!
rSet.Put( SfxBoolItem( SID_GALLERY_ENABLE_ADDCOPY, sal_True ) );
break;
case FN_EDIT_REGION:
if( !rSh.IsAnySectionInDoc() )
rSet.DisableItem(nWhich);
break;
case FN_INSERT_REGION:
if( rSh.CrsrInsideInputFld()
|| rSh.IsSelFrmMode()
|| !rSh.IsInsRegionAvailable() )
{
rSet.DisableItem( nWhich );
}
break;
case FN_CONVERT_TABLE_TO_TEXT:
{
sal_uInt16 eFrmType = rSh.GetFrmType(0,sal_True);
if( (eFrmType & FRMTYPE_FOOTNOTE) ||
!rSh.GetTableFmt() )
rSet.DisableItem( nWhich );
}
break;
case FN_CONVERT_TEXT_TO_TABLE:
{
sal_uInt16 eFrmType = rSh.GetFrmType(0,sal_True);
if( (eFrmType & FRMTYPE_FOOTNOTE) ||
!rSh.IsTextToTableAvailable() )
rSet.DisableItem( nWhich );
}
break;
case FN_CONVERT_TEXT_TABLE:
{
sal_uInt16 eFrmType = rSh.GetFrmType(0,sal_True);
if( (eFrmType & FRMTYPE_FOOTNOTE) ||
(!rSh.GetTableFmt() && !rSh.IsTextToTableAvailable() ) )
rSet.DisableItem( nWhich );
}
break;
case RES_SHADOW:
{
SfxItemSet aSet( rSh.GetAttrPool(),
RES_SHADOW, RES_SHADOW );
// Tabellenzelle(n) selektiert?
if ( rSh.IsTableMode() )
{
SwFrmFmt *pFmt = rSh.GetTableFmt();
aSet.Put(pFmt->GetFmtAttr( nWhich, sal_True ));
}
else if( rSh.IsFrmSelected() )
{
SwFlyFrmAttrMgr aMgr( sal_False, &rSh, FRMMGR_TYPE_NONE );
aSet.Put( aMgr.GetAttrSet() );
}
else
rSh.GetCurAttr( aSet );
#if OSL_DEBUG_LEVEL > 1
const SvxShadowItem& rShItem = (const SvxShadowItem&)aSet.Get(nWhich);
rSet.Put(rShItem);
#else
rSet.Put((const SvxShadowItem&)aSet.Get(nWhich));
#endif
}
break;
case SID_IMAP:
{
// --> OD 2006-11-08 #i59688#
// improve efficiency:
// If selected object is protected, item has to disabled.
const sal_Bool bProtect = 0 != rSh.IsSelObjProtected(FLYPROTECT_CONTENT|FLYPROTECT_PARENT);
if ( bProtect )
{
rSet.DisableItem( nWhich );
}
else
{
const sal_uInt16 nId = SvxIMapDlgChildWindow::GetChildWindowId();
const sal_Bool bHas = pVFrame->HasChildWindow( nId );
const sal_Bool bFrmSel = rSh.IsFrmSelected();
const sal_Bool bIsGraphicSelection =
rSh.GetSelectionType() == nsSelectionType::SEL_GRF;
// --> OD 2006-11-08 #i59688#
// avoid unnecessary loading of selected graphic.
// The graphic is only needed, if the dialog is open.
//wenn die Grafik ausgeswappt ist, dann muss der
//Status asynchron ermittelt werden
//bis dahin wird der Slot disabled
if ( bHas && bIsGraphicSelection && rSh.IsGrfSwapOut( sal_True ) )
{
if( AddGrfUpdateSlot( nWhich ))
rSh.GetGraphic(sal_False); // start the loading
}
else
{
if ( !bHas &&
( !bFrmSel ||
( bIsGraphicSelection &&
rSh.GetGraphicType() == GRAPHIC_NONE ) ) )
{
rSet.DisableItem( nWhich );
}
else
{
SfxBoolItem aBool(nWhich, bHas);
if ( bHas && bFrmSel )
lcl_UpdateIMapDlg( rSh );
rSet.Put(aBool);
}
}
// <--
}
// <--
}
break;
case SID_IMAP_EXEC:
{
sal_Bool bDisable = sal_False;
if( !rSh.IsFrmSelected())
bDisable = sal_True;
sal_uInt16 nId = SvxIMapDlgChildWindow::GetChildWindowId();
if(!bDisable && pVFrame->HasChildWindow( nId ))
{
if(rSh.GetSelectionType() == nsSelectionType::SEL_GRF
&& rSh.IsGrfSwapOut(sal_True))
{
if( AddGrfUpdateSlot( nWhich ))
rSh.GetGraphic(sal_False); // start the loading
}
else
{
SvxIMapDlg *pDlg = SWIMAPDLG(GetView());
if( pDlg->GetEditingObject() != rSh.GetIMapInventor() )
lcl_UpdateIMapDlg( rSh );
}
}
rSet.Put(SfxBoolItem(nWhich, bDisable));
}
break;
case FN_BACKSPACE:
case SID_DELETE:
if ( ( rSh.HasReadonlySel() && !rSh.CrsrInsideInputFld() )
|| rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) != 0 )
{
rSet.DisableItem( nWhich );
}
break;
case SID_CONTOUR_DLG:
{
sal_Bool bParentCntProt = 0 != rSh.IsSelObjProtected(FLYPROTECT_CONTENT|FLYPROTECT_PARENT );
if( bParentCntProt || 0 != (HTMLMODE_ON & ::GetHtmlMode(
GetView().GetDocShell() )) )
rSet.DisableItem( nWhich );
else
{
sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
sal_Bool bHas = GetView().GetViewFrame()->HasChildWindow( nId );
int nSel = rSh.GetSelectionType();
sal_Bool bOk = 0 != (nSel & (nsSelectionType::SEL_GRF|nsSelectionType::SEL_OLE));
sal_Bool bDisable = sal_False;
if( !bHas && !bOk )
bDisable = sal_True;
// --> OD 2006-11-08 #i59688#
// avoid unnecessary loading of selected graphic.
// The graphic is only needed, if the dialog is open.
// wenn die Grafik ausgeswappt ist, dann muss der Status
// asynchron ermittelt werden bis dahin wird der Slot
// disabled
else if ( bHas && (nSel & nsSelectionType::SEL_GRF) &&
rSh.IsGrfSwapOut(sal_True) )
{
if( AddGrfUpdateSlot( nWhich ))
rSh.GetGraphic(sal_False); // start the loading
// --> OD 2007-07-04 #i75481#
bDisable = sal_True;
// <--
}
else if( bHas && bOk )
bDisable = !lcl_UpdateContourDlg( rSh, nSel );
else if( bOk )
{
// --> OD 2007-07-04 #i75481#
// apply fix #i59688# only for selected graphics
if ( nSel & nsSelectionType::SEL_GRF )
bDisable = GRAPHIC_NONE == rSh.GetGraphicType();
else
bDisable = GRAPHIC_NONE == rSh.GetIMapGraphic().GetType();
// <--
}
// <--
if( bDisable )
rSet.DisableItem( nWhich );
else
rSet.Put( SfxBoolItem(nWhich, bHas) );
}
}
break;
case SID_CONTOUR_EXEC:
{
sal_Bool bDisable = sal_False;
int nSel = rSh.GetSelectionType();
if( !(nSel & (nsSelectionType::SEL_GRF|nsSelectionType::SEL_OLE)) )
bDisable = sal_True;
sal_uInt16 nId = SvxContourDlgChildWindow::GetChildWindowId();
if( !bDisable && GetView().GetViewFrame()->HasChildWindow( nId ))
{
SvxContourDlg *pDlg = SWCONTOURDLG(GetView());
if( pDlg->GetEditingObject() != rSh.GetIMapInventor() )
bDisable = sal_True;
}
rSet.Put(SfxBoolItem(nWhich, bDisable));
}
break;
case FN_TOOL_ANKER:
case FN_TOOL_ANKER_PAGE:
case FN_TOOL_ANKER_PARAGRAPH:
case FN_TOOL_ANKER_CHAR:
case FN_TOOL_ANKER_AT_CHAR:
case FN_TOOL_ANKER_FRAME:
{
sal_Bool bObj = 0 != rSh.IsObjSelected();
sal_Bool bParentCntProt = rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) != 0;
if( !bParentCntProt && (bObj || rSh.IsFrmSelected()))
{
SfxItemSet aSet(GetPool(), RES_ANCHOR, RES_ANCHOR);
if(bObj)
rSh.GetObjAttr(aSet);
else
rSh.GetFlyFrmAttr(aSet);
RndStdIds eSet = ((SwFmtAnchor&)aSet.Get(RES_ANCHOR)).GetAnchorId();
const sal_Bool bSet =
((nWhich == FN_TOOL_ANKER_PAGE) &&
(eSet == FLY_AT_PAGE))
|| ((nWhich == FN_TOOL_ANKER_PARAGRAPH) &&
(eSet == FLY_AT_PARA))
|| ((nWhich == FN_TOOL_ANKER_FRAME) &&
(eSet == FLY_AT_FLY))
|| ((nWhich == FN_TOOL_ANKER_AT_CHAR) &&
(eSet == FLY_AT_CHAR))
|| ((nWhich == FN_TOOL_ANKER_CHAR) &&
(eSet == FLY_AS_CHAR));
if(nWhich != FN_TOOL_ANKER)
{
sal_uInt16 nHtmlMode = ::GetHtmlMode(GetView().GetDocShell());
if( ( nWhich == FN_TOOL_ANKER_PAGE &&
((HTMLMODE_ON & nHtmlMode) && (0 == (nHtmlMode & HTMLMODE_SOME_ABS_POS)))) ||
( nWhich == FN_TOOL_ANKER_FRAME && !rSh.IsFlyInFly() ) )
rSet.DisableItem(nWhich);
else
rSet.Put(SfxBoolItem(nWhich, bSet));
}
else
{
sal_uInt16 nSlotId = 0;
switch (eSet)
{
case FLY_AT_PAGE:
nSlotId = FN_TOOL_ANKER_PAGE;
break;
case FLY_AT_PARA:
nSlotId = FN_TOOL_ANKER_PARAGRAPH;
break;
case FLY_AS_CHAR:
nSlotId = FN_TOOL_ANKER_CHAR;
break;
case FLY_AT_CHAR:
nSlotId = FN_TOOL_ANKER_AT_CHAR;
break;
case FLY_AT_FLY:
nSlotId = FN_TOOL_ANKER_FRAME;
break;
default:
;
}
rSet.Put(SfxUInt16Item(nWhich, nSlotId));
}
}
else
rSet.DisableItem( nWhich );
}
break;
case FN_FRAME_NOWRAP:
case FN_FRAME_WRAP:
case FN_FRAME_WRAP_IDEAL:
case FN_FRAME_WRAPTHRU:
case FN_FRAME_WRAPTHRU_TRANSP:
case FN_FRAME_WRAP_CONTOUR:
case FN_WRAP_ANCHOR_ONLY:
case FN_FRAME_WRAP_LEFT:
case FN_FRAME_WRAP_RIGHT:
{
sal_Bool bObj = 0 != rSh.IsObjSelected();
sal_Bool bParentCntProt = rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) != 0;
if( !bParentCntProt && (bObj || rSh.IsFrmSelected()))
{
SfxItemSet aSet(GetPool(), RES_OPAQUE, RES_ANCHOR);
int nAnchorType;
if(bObj)
{
rSh.GetObjAttr(aSet);
nAnchorType = rSh.GetAnchorId();
}
else
{
rSh.GetFlyFrmAttr(aSet);
nAnchorType = ((SwFmtAnchor&)aSet.Get(RES_ANCHOR)).GetAnchorId();
}
const SwFmtSurround& rWrap = (const SwFmtSurround&)aSet.Get(RES_SURROUND);
const SvxOpaqueItem& rOpaque = (const SvxOpaqueItem&)aSet.Get(RES_OPAQUE);
sal_Bool bOpaque = rOpaque.GetValue();
SwSurround nSurround = rWrap.GetSurround();
sal_Bool bSet = sal_False;
bool bDisable =
(nAnchorType == - 1) || (nAnchorType == FLY_AS_CHAR);
const bool bHtmlMode =
0 != ::GetHtmlMode(GetView().GetDocShell());
switch( nWhich )
{
case FN_FRAME_NOWRAP:
bDisable |=
( (nAnchorType != FLY_AT_PARA)
&& (nAnchorType != FLY_AT_CHAR)
&& (nAnchorType != FLY_AT_PAGE));
bSet = nSurround == SURROUND_NONE;
break;
case FN_FRAME_WRAP:
bDisable |= bHtmlMode;
bSet = nSurround == SURROUND_PARALLEL;
break;
case FN_FRAME_WRAP_IDEAL:
bDisable |= bHtmlMode;
bSet = nSurround == SURROUND_IDEAL;
break;
case FN_FRAME_WRAPTHRU:
bDisable |= (bHtmlMode ||
( (nAnchorType != FLY_AT_PARA)
&& (nAnchorType != FLY_AT_CHAR)
&& (nAnchorType != FLY_AT_PAGE)));
if(bObj)
bSet = nSurround == SURROUND_THROUGHT && rSh.GetLayerId();
else
bSet = nSurround == SURROUND_THROUGHT && bOpaque;
break;
case FN_FRAME_WRAPTHRU_TRANSP:
bDisable |= bHtmlMode;
if(bObj)
bSet = nSurround == SURROUND_THROUGHT && !rSh.GetLayerId();
else
bSet = nSurround == SURROUND_THROUGHT && !bOpaque;
break;
case FN_FRAME_WRAP_CONTOUR:
bDisable |= bHtmlMode;
//no contour available whenn no wrap or wrap through is set
bDisable |= (nSurround == SURROUND_NONE || nSurround == SURROUND_THROUGHT);
bSet = rWrap.IsContour();
if( !bDisable )
{
int nSel = rSh.GetSelectionType();
if( (nSel & nsSelectionType::SEL_GRF) &&
rSh.IsGrfSwapOut(sal_True))
{
if( AddGrfUpdateSlot( nWhich ))
rSh.GetGraphic(sal_False); // start the loading
}
else if( rSh.IsFrmSelected() )
{
// #i102253# applied patch from OD (see task)
bDisable =
nSel & nsSelectionType::SEL_FRM ||
GRAPHIC_NONE == rSh.GetIMapGraphic().GetType();
}
}
bSet = bDisable ? sal_False : rWrap.IsContour();
break;
case FN_WRAP_ANCHOR_ONLY:
bDisable |= (bHtmlMode ||
(nAnchorType != FLY_AT_PARA));
bSet = rWrap.IsAnchorOnly();
break;
case FN_FRAME_WRAP_LEFT:
bSet = nSurround == SURROUND_LEFT;
break;
case FN_FRAME_WRAP_RIGHT:
bSet = nSurround == SURROUND_RIGHT;
break;
}
if(bDisable)
rSet.DisableItem(nWhich);
else
rSet.Put(SfxBoolItem(nWhich, bSet));
}
else
rSet.DisableItem(nWhich);
}
break;
case FN_UPDATE_CHARTS:
if( !rSh.HasCharts() )
rSet.DisableItem( nWhich );
break;
case FN_UPDATE_ALL_LINKS:
if ( !rSh.GetLinkManager().GetLinks().Count() )
rSet.DisableItem(nWhich);
break;
case FN_XFORMS_DESIGN_MODE:
// enable if in XForms document
if( rSh.GetDoc()->isXForms() )
{
// determine current state from view options
sal_Bool bValue = ! rSh.GetViewOptions()->IsFormView();
rSet.Put( SfxBoolItem( nWhich, bValue ) );
}
else
rSet.Put( SfxVisibilityItem( nWhich, sal_False ) );
break;
}
nWhich = aIter.NextWhich();
}
pGetStateSet = 0;
}
/*--------------------------------------------------------------------
Beschreibung: Slots mit dieser Statusmethode disablen
--------------------------------------------------------------------*/
void SwBaseShell::StateDisableItems( SfxItemSet &rSet )
{
SfxWhichIter aIter(rSet);
sal_uInt16 nWhich = aIter.FirstWhich();
while (nWhich)
{
rSet.DisableItem( nWhich );
nWhich = aIter.NextWhich();
}
}
/*--------------------------------------------------------------------
Beschreibung: Slots mit dieser Statusmethode disablen
--------------------------------------------------------------------*/
void SwBaseShell::StateStyle( SfxItemSet &rSet )
{
sal_Bool bParentCntProt = GetShell().IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) != 0;
ShellModes eMode = GetView().GetShellMode();
if ( bParentCntProt ||
SHELL_MODE_DRAW == eMode ||
SHELL_MODE_DRAW_CTRL == eMode ||
SHELL_MODE_DRAW_FORM == eMode ||
SHELL_MODE_DRAWTEXT == eMode ||
SHELL_MODE_BEZIER == eMode )
{
SfxWhichIter aIter( rSet );
sal_uInt16 nWhich = aIter.FirstWhich();
while ( nWhich )
{
rSet.DisableItem( nWhich );
nWhich = aIter.NextWhich();
}
}
else
GetView().GetDocShell()->StateStyleSheet(rSet, &GetShell());
}
/*--------------------------------------------------------------------
Beschreibung:
--------------------------------------------------------------------*/
void SwBaseShell::SetWrapMode( sal_uInt16 nSlot )
{
SwWrtShell &rSh = GetShell();
sal_Bool bObj = 0 != rSh.IsObjSelected();
if( bObj || rSh.IsFrmSelected())
{
SfxItemSet aSet(GetPool(), RES_OPAQUE, RES_SURROUND);
if(bObj)
rSh.GetObjAttr(aSet);
else
rSh.GetFlyFrmAttr(aSet);
SwFmtSurround aWrap( (SwFmtSurround&)aSet.Get(RES_SURROUND) );
SwSurround nOldSurround(aWrap.GetSurround());
SwSurround nSurround = SURROUND_PARALLEL;
switch (nSlot)
{
case FN_FRAME_NOWRAP:
nSurround = SURROUND_NONE;
if (aWrap.IsContour())
aWrap.SetContour(sal_False);
break;
case FN_FRAME_WRAP_IDEAL:
nSurround = SURROUND_IDEAL;
break;
case FN_WRAP_ANCHOR_ONLY:
aWrap.SetAnchorOnly(!aWrap.IsAnchorOnly());
// --> OD 2006-06-02 #b6432130#
// keep previous wrapping
// --> OD 2006-09-21 #138144# - adjust fix #b6432130#
// switch to wrap SURROUND_PARALLEL, if previous wrap is SURROUND_NONE
if ( nOldSurround != SURROUND_NONE )
{
nSurround = nOldSurround;
}
// <--
break;
case FN_FRAME_WRAP_CONTOUR:
aWrap.SetContour(!aWrap.IsContour());
if (nSurround == SURROUND_THROUGHT)
nSurround = SURROUND_PARALLEL;
break;
case FN_FRAME_WRAPTHRU_TRANSP:
if (aWrap.IsContour())
aWrap.SetContour(sal_False);
// kein break!!!
case FN_FRAME_WRAPTHRU:
nSurround = SURROUND_THROUGHT;
break;
case FN_FRAME_WRAP_LEFT:
nSurround = SURROUND_LEFT;
break;
case FN_FRAME_WRAP_RIGHT:
nSurround = SURROUND_RIGHT;
break;
default:
break;
}
aWrap.SetSurround(nSurround);
if (nSlot != FN_FRAME_WRAP_CONTOUR)
{
// Konturumfluss bei Draw-Objekten defaulten
if (bObj && nOldSurround != nSurround &&
(nOldSurround == SURROUND_NONE || nOldSurround == SURROUND_THROUGHT))
{
aWrap.SetContour(sal_True);
}
}
aSet.Put( aWrap );
aSet.Put(SvxOpaqueItem(RES_OPAQUE, nSlot != FN_FRAME_WRAPTHRU_TRANSP));
if(bObj)
{
rSh.SetObjAttr(aSet);
if (nSlot != FN_FRAME_WRAPTHRU_TRANSP)
rSh.SelectionToHeaven();
else
rSh.SelectionToHell();
}
else
rSh.SetFlyFrmAttr(aSet);
}
}
/*--------------------------------------------------------------------
Beschreibung: Update der Statuszeile erzwingen
--------------------------------------------------------------------*/
void SwBaseShell::SetFrmMode(FlyMode eMode, SwWrtShell *pSh )
{
eFrameMode = eMode;
SfxBindings &rBnd = pSh->GetView().GetViewFrame()->GetBindings();
if( eMode == FLY_DRAG ||
(pSh && (pSh->IsFrmSelected() || pSh->IsObjSelected())) )
{
const SfxPointItem aTmp1( SID_ATTR_POSITION, pSh->GetAnchorObjDiff());
const SvxSizeItem aTmp2( SID_ATTR_SIZE, pSh->GetObjSize());
rBnd.SetState( aTmp1 );
rBnd.SetState( aTmp2 );
}
else if( eMode == FLY_DRAG_END )
{
static sal_uInt16 __READONLY_DATA aInval[] =
{
SID_ATTR_POSITION, SID_ATTR_SIZE, 0
};
rBnd.Invalidate(aInval);
}
}
/*--------------------------------------------------------------------
Beschreibung: Ctor
--------------------------------------------------------------------*/
SwBaseShell::SwBaseShell(SwView& rVw) :
SfxShell( &rVw ),
rView(rVw),
pGetStateSet(0)
{
SwWrtShell& rWrtSh = rView.GetWrtShell();
SetPool(&rWrtSh.GetAttrPool());
SetName(C2S("Base"));
rWrtSh.SetGrfArrivedLnk( LINK( this, SwBaseShell, GraphicArrivedHdl));
}
SwBaseShell::~SwBaseShell()
{
if( rView.GetCurShell() == this )
rView.ResetSubShell();
Link aTmp( LINK( this, SwBaseShell, GraphicArrivedHdl));
if( aTmp == rView.GetWrtShell().GetGrfArrivedLnk() )
rView.GetWrtShell().SetGrfArrivedLnk( Link() );
}
/*--------------------------------------------------------------------
Beschreibung:
--------------------------------------------------------------------*/
void SwBaseShell::ExecTxtCtrl( SfxRequest& rReq )
{
const SfxItemSet *pArgs = rReq.GetArgs();
if( pArgs)
{
SwWrtShell &rSh = GetShell();
SvxScriptSetItem* pSSetItem = 0;
sal_uInt16 nSlot = rReq.GetSlot();
SfxItemPool& rPool = rSh.GetAttrPool();
sal_uInt16 nWhich = rPool.GetWhich( nSlot );
sal_uInt16 nScripts = SCRIPTTYPE_LATIN | SCRIPTTYPE_ASIAN | SCRIPTTYPE_COMPLEX;
SfxItemSet aHeightSet( GetPool(), RES_CHRATR_FONTSIZE, RES_CHRATR_FONTSIZE,
RES_CHRATR_CJK_FONTSIZE, RES_CHRATR_CJK_FONTSIZE,
RES_CHRATR_CTL_FONTSIZE, RES_CHRATR_CTL_FONTSIZE,
0L);
switch( nSlot )
{
case SID_ATTR_CHAR_FONT:
{
nScripts = rSh.GetScriptType();
// #i42732# input language should be preferred over
// current cursor position to detect script type
if(!rSh.HasSelection())
{
LanguageType nInputLang = GetView().GetEditWin().GetInputLanguage();
if(nInputLang != LANGUAGE_DONTKNOW && nInputLang != LANGUAGE_SYSTEM)
nScripts = SvtLanguageOptions::GetScriptTypeOfLanguage( nInputLang );
}
}
case SID_ATTR_CHAR_POSTURE:
case SID_ATTR_CHAR_WEIGHT:
{
pSSetItem = new SvxScriptSetItem( nSlot, rPool );
pSSetItem->PutItemForScriptType( nScripts, pArgs->Get( nWhich ));
pArgs = &pSSetItem->GetItemSet();
}
break;
case SID_ATTR_CHAR_FONTHEIGHT:
{
if(rSh.HasSelection())
{
pSSetItem = new SvxScriptSetItem( nSlot, rPool );
pSSetItem->PutItemForScriptType( nScripts, pArgs->Get( nWhich ));
pArgs = &pSSetItem->GetItemSet();
}
else
{
nScripts = rSh.GetScriptType();
LanguageType nInputLang = GetView().GetEditWin().GetInputLanguage();
if(nInputLang != LANGUAGE_DONTKNOW && nInputLang != LANGUAGE_SYSTEM)
nScripts = SvtLanguageOptions::GetScriptTypeOfLanguage( nInputLang );
sal_uInt32 nHeight = static_cast< const SvxFontHeightItem& >(pArgs->Get( nWhich )).GetHeight();
SwStdFontConfig* pStdFont = SW_MOD()->GetStdFontConfig();
SfxItemSet aLangSet( GetPool(), RES_CHRATR_LANGUAGE, RES_CHRATR_LANGUAGE,
RES_CHRATR_CJK_LANGUAGE, RES_CHRATR_CJK_LANGUAGE,
RES_CHRATR_CTL_LANGUAGE, RES_CHRATR_CTL_LANGUAGE,
0L);
rSh.GetCurAttr( aLangSet );
sal_Int32 nWesternSize =
pStdFont->GetFontHeight(FONT_STANDARD, FONT_GROUP_DEFAULT,
static_cast<const SvxLanguageItem&>(aLangSet.Get( RES_CHRATR_LANGUAGE)).GetLanguage());
sal_Int32 nCJKSize =
pStdFont->GetFontHeight(FONT_STANDARD, FONT_GROUP_CJK,
static_cast<const SvxLanguageItem&>(aLangSet.Get( RES_CHRATR_CJK_LANGUAGE)).GetLanguage());
sal_Int32 nCTLSize =
pStdFont->GetFontHeight(FONT_STANDARD, FONT_GROUP_CTL,
static_cast<const SvxLanguageItem&>(aLangSet.Get( RES_CHRATR_CTL_LANGUAGE)).GetLanguage());
switch(nScripts)
{
case SCRIPTTYPE_LATIN:
nCJKSize = nHeight * nCJKSize / nWesternSize;
nCTLSize = nHeight * nCTLSize / nWesternSize;
nWesternSize = (sal_Int32) nHeight;
break;
case SCRIPTTYPE_ASIAN:
nCTLSize = nHeight* nCTLSize / nCJKSize;
nWesternSize = nHeight * nWesternSize / nCJKSize;
nCJKSize = (sal_Int32) nHeight;
break;
case SCRIPTTYPE_COMPLEX:
nCJKSize = nHeight * nCJKSize / nCTLSize;
nWesternSize = nHeight * nWesternSize / nCTLSize;
nCTLSize = (sal_Int32) nHeight;
break;
}
aHeightSet.Put( SvxFontHeightItem( (sal_uInt32)nWesternSize, 100, RES_CHRATR_FONTSIZE ));
aHeightSet.Put( SvxFontHeightItem( (sal_uInt32)nCJKSize, 100, RES_CHRATR_CJK_FONTSIZE ));
aHeightSet.Put( SvxFontHeightItem( (sal_uInt32)nCTLSize, 100, RES_CHRATR_CTL_FONTSIZE ));
pArgs = &aHeightSet;
}
}
break;
}
if( pArgs )
{
bool bAuto = false;
if ( !isCHRATR(nWhich) ||
( rSh.HasSelection() && rSh.IsSelFullPara() ) )
{
SwTxtFmtColl * pColl = rSh.GetCurTxtFmtColl();
if ( pColl && pColl->IsAutoUpdateFmt() )
{
rSh.AutoUpdatePara( pColl, *pArgs );
bAuto = true;
}
}
if (!bAuto)
{
rSh.SetAttrSet( *pArgs );
}
}
delete pSSetItem;
}
else
GetView().GetViewFrame()->GetDispatcher()->Execute( SID_CHAR_DLG, sal_False);
rReq.Done();
}
/*--------------------------------------------------------------------
Beschreibung:
--------------------------------------------------------------------*/
void SwBaseShell::GetTxtCtrlState( SfxItemSet& rSet )
{
SwWrtShell &rSh = GetShell();
rSh.GetCurAttr( rSet );
}
void SwBaseShell::GetTxtFontCtrlState( SfxItemSet& rSet )
{
SwWrtShell &rSh = GetShell();
sal_Bool bFirst = sal_True;
SfxItemSet* pFntCoreSet = 0;
sal_uInt16 nScriptType = SCRIPTTYPE_LATIN;
SfxWhichIter aIter( rSet );
sal_uInt16 nWhich = aIter.FirstWhich();
while( nWhich )
{
switch( nWhich )
{
case RES_CHRATR_FONT:
case RES_CHRATR_FONTSIZE:
case RES_CHRATR_WEIGHT:
case RES_CHRATR_POSTURE:
{
if( !pFntCoreSet )
{
pFntCoreSet = new SfxItemSet( *rSet.GetPool(),
RES_CHRATR_BEGIN, RES_CHRATR_END-1 );
rSh.GetCurAttr( *pFntCoreSet );
nScriptType = rSh.GetScriptType();
// #i42732# input language should be preferred over
// current cursor position to detect script type
SwEditWin& rEditWin = GetView().GetEditWin();
if( rEditWin.IsUseInputLanguage() )
{
if(!rSh.HasSelection() && (
nWhich == RES_CHRATR_FONT ||
nWhich == RES_CHRATR_FONTSIZE ))
{
LanguageType nInputLang = rEditWin.GetInputLanguage();
if(nInputLang != LANGUAGE_DONTKNOW && nInputLang != LANGUAGE_SYSTEM)
nScriptType = SvtLanguageOptions::GetScriptTypeOfLanguage( nInputLang );
}
}
}
SfxItemPool& rPool = *rSet.GetPool();
SvxScriptSetItem aSetItem( rPool.GetSlotId( nWhich ), rPool );
aSetItem.GetItemSet().Put( *pFntCoreSet, sal_False );
const SfxPoolItem* pI = aSetItem.GetItemOfScript( nScriptType );
if( pI )
rSet.Put( *pI, nWhich );
else
rSet.InvalidateItem( nWhich );
//set input context of the SwEditWin according to the selected font and script type
if(RES_CHRATR_FONT == nWhich)
{
Font aFont;
if(pI && pI->ISA(SvxFontItem))
{
aFont.SetName( ((const SvxFontItem*)pI)->GetFamilyName());
aFont.SetStyleName(((const SvxFontItem*)pI)->GetStyleName());
aFont.SetFamily(((const SvxFontItem*)pI)->GetFamily());
aFont.SetPitch(((const SvxFontItem*)pI)->GetPitch());
aFont.SetCharSet(((const SvxFontItem*)pI)->GetCharSet());
}
sal_Bool bVertical = rSh.IsInVerticalText();
aFont.SetOrientation(bVertical ? 2700 : 0);
aFont.SetVertical(bVertical);
GetView().GetEditWin().SetInputContext( InputContext( aFont, INPUTCONTEXT_TEXT |
INPUTCONTEXT_EXTTEXTINPUT ) );
}
}
break;
default:
if( bFirst )
{
rSh.GetCurAttr( rSet );
bFirst = sal_False;
}
}
nWhich = aIter.NextWhich();
}
delete pFntCoreSet;
}
/*--------------------------------------------------------------------
Beschreibung:
--------------------------------------------------------------------*/
void SwBaseShell::GetBckColState(SfxItemSet &rSet)
{
SwWrtShell &rSh = GetShell();
SfxWhichIter aIter( rSet );
sal_uInt16 nWhich = aIter.FirstWhich();
int nSelType = rSh.GetSelectionType();
// if ( nSelType & nsSelectionType::SEL_GRF ||
if( nSelType & nsSelectionType::SEL_OLE )
{
rSet.DisableItem( SID_BACKGROUND_COLOR );
return;
}
if ( nSelType & nsSelectionType::SEL_FRM )
{
sal_Bool bParentCntProt = rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) != 0;
if (bParentCntProt)
{
rSet.DisableItem( SID_BACKGROUND_COLOR );
return;
}
}
SvxBrushItem aBrushItem( RES_BACKGROUND );
if( nsSelectionType::SEL_TBL_CELLS & nSelType )
rSh.GetBoxBackground( aBrushItem );
else
{
SfxItemSet aCoreSet(GetPool(), RES_BACKGROUND, RES_BACKGROUND);
if( nSelType & nsSelectionType::SEL_GRF || nsSelectionType::SEL_FRM & nSelType )
rSh.GetFlyFrmAttr( aCoreSet );
else
rSh.GetCurAttr( aCoreSet );
aBrushItem = (const SvxBrushItem&)aCoreSet.Get(RES_BACKGROUND);
}
while ( nWhich )
{
switch(nWhich)
{
case SID_BACKGROUND_COLOR :
{
SvxColorItem aColorItem(aBrushItem.GetColor(), SID_BACKGROUND_COLOR);
rSet.Put( aColorItem, SID_BACKGROUND_COLOR );
}
break;
case SID_ATTR_BRUSH:
case RES_BACKGROUND:
rSet.Put( aBrushItem, GetPool().GetWhich(nWhich) );
break;
}
nWhich = aIter.NextWhich();
}
}
/*--------------------------------------------------------------------
Beschreibung:
--------------------------------------------------------------------*/
void SwBaseShell::ExecBckCol(SfxRequest& rReq)
{
SwWrtShell &rSh = GetShell();
int nSelType = rSh.GetSelectionType();
if ( nSelType & nsSelectionType::SEL_OLE )
{
return;
}
const SfxItemSet* pArgs = rReq.GetArgs();
sal_uInt16 nSlot = rReq.GetSlot();
if( !pArgs && nSlot != SID_BACKGROUND_COLOR)
return ;
SvxBrushItem aBrushItem( RES_BACKGROUND );
if( nsSelectionType::SEL_TBL_CELLS & nSelType )
{
rSh.GetBoxBackground( aBrushItem );
}
else
{
SfxItemSet aCoreSet(GetPool(), RES_BACKGROUND, RES_BACKGROUND);
if( (nsSelectionType::SEL_FRM & nSelType) || (nsSelectionType::SEL_GRF & nSelType) )
rSh.GetFlyFrmAttr( aCoreSet );
else
rSh.GetCurAttr( aCoreSet );
aBrushItem = (const SvxBrushItem&)aCoreSet.Get(RES_BACKGROUND);
}
// sal_Bool bMsgOk = sal_False;
switch (nSlot)
{
// RES_BACKGROUND (=SID_ATTR_BRUSH) muss ueber zwei IDs
// gesetzt werden:
case SID_BACKGROUND_COLOR:
{
aBrushItem.SetGraphicPos(GPOS_NONE);
//Brush &rBrush = aBrushItem.GetBrush();
if(pArgs)
{
const SvxColorItem& rNewColorItem = (const SvxColorItem&)
pArgs->Get(SID_BACKGROUND_COLOR);
const Color& rNewColor = rNewColorItem.GetValue();
aBrushItem.SetColor( rNewColor );
GetView().GetViewFrame()->GetBindings().SetState(rNewColorItem);
}
else
{
aBrushItem.SetColor( COL_TRANSPARENT );
rReq.AppendItem( SvxColorItem( Color( COL_TRANSPARENT ), nSlot ) );
}
}
break;
case SID_ATTR_BRUSH:
case RES_BACKGROUND:
{
const SvxBrushItem& rNewBrushItem = (const SvxBrushItem&)
pArgs->Get( GetPool().GetWhich(nSlot) );
aBrushItem = rNewBrushItem;
}
break;
default:
// bMsgOk = sal_False;
rReq.Ignore();
DBG_ERROR( "Unbekannte Message bei ExecuteAttr!" );
return;
}
if( nsSelectionType::SEL_TBL_CELLS & nSelType )
{
rSh.SetBoxBackground( aBrushItem );
}
else if( (nsSelectionType::SEL_FRM & nSelType) ||
(nsSelectionType::SEL_GRF & nSelType) )
{
SfxItemSet aCoreSet(GetPool(), RES_BACKGROUND, RES_BACKGROUND);
aCoreSet.Put( aBrushItem );
// Vorlagen-AutoUpdate
SwFrmFmt* pFmt = rSh.GetCurFrmFmt();
if(pFmt && pFmt->IsAutoUpdateFmt())
rSh.AutoUpdateFrame( pFmt, aCoreSet);
else
rSh.SetFlyFrmAttr( aCoreSet );
}
else
{
SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl();
if( pColl && pColl->IsAutoUpdateFmt())
{
SfxItemSet aSet(GetPool(), RES_BACKGROUND, RES_BACKGROUND );
aSet.Put(aBrushItem);
rSh.AutoUpdatePara( pColl, aSet);
}
else
rSh.SetAttrItem( aBrushItem );
}
rReq.Done();
}
/*--------------------------------------------------------------------
Beschreibung:
--------------------------------------------------------------------*/
void SwBaseShell::GetBorderState(SfxItemSet &rSet)
{
SwWrtShell &rSh = GetShell();
// Tabellenzelle(n) selektiert?
sal_Bool bPrepare = sal_True;
sal_Bool bTableMode = rSh.IsTableMode();
if ( bTableMode )
{
SfxItemSet aCoreSet( GetPool(),
RES_BOX, RES_BOX,
SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 );
SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
aCoreSet.Put( aBoxInfo );
rSh.GetTabBorders( aCoreSet );
rSet.Put( aCoreSet );
}
else if ( rSh.IsFrmSelected() )
{
SwFlyFrmAttrMgr aMgr( sal_False, &rSh, FRMMGR_TYPE_NONE );
rSet.Put( aMgr.GetAttrSet() );
bPrepare = sal_False;
}
else
// Umrandungsattribute ganz normal ueber Shell holen
rSh.GetCurAttr( rSet );
if ( bPrepare )
::PrepareBoxInfo( rSet, rSh );
// switch the border toolbox controller mode
rSet.Put( SfxBoolItem( SID_BORDER_REDUCED_MODE, !bTableMode ));
}
/*--------------------------------------------------------------------
Beschreibung:
--------------------------------------------------------------------*/
void SwBaseShell::ExecDlg(SfxRequest &rReq)
{
SwWrtShell &rSh = GetShell();
Window *pMDI = &GetView().GetViewFrame()->GetWindow();
//Damit aus dem Basic keine Dialoge fuer Hintergrund-Views aufgerufen werden:
sal_Bool bBackground = (&GetView() != GetActiveView());
const SfxPoolItem* pItem = 0;
const SfxItemSet* pArgs = rReq.GetArgs();
sal_uInt16 nSlot = rReq.GetSlot();
const SfxItemSet* pOutSet = 0;
bool bDone = false;
if(pArgs)
pArgs->GetItemState( GetPool().GetWhich(nSlot), sal_False, &pItem );
switch ( nSlot )
{
case FN_FORMAT_PAGE_DLG:
case FN_FORMAT_PAGE_COLUMN_DLG:
case FN_FORMAT_PAGE_SETTING_DLG:
{
if( !bBackground )
{
const sal_uInt16 nCurIdx = rSh.GetCurPageDesc();
const SwPageDesc& rPageDesc = rSh.GetPageDesc( nCurIdx );
//temp. View, weil die Shell nach dem Dialog nicht mehr gueltig sein muss
//z.B. Kopfzeile ausschalten
SwView& rTempView = GetView();
rTempView.GetDocShell()->FormatPage(
rPageDesc.GetName(),
nSlot,
rSh );
rTempView.InvalidateRulerPos();
}
}
break;
case FN_FORMAT_BORDER_DLG:
{
SfxItemSet aSet( rSh.GetAttrPool(),
RES_BOX , RES_SHADOW,
SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER,
0 );
SfxAbstractDialog * pDlg = 0;
// Tabellenzelle(n) selektiert?
if ( rSh.IsTableMode() )
{
// Umrandungattribute Get/SetTabBorders() setzen
::PrepareBoxInfo( aSet, rSh );
rSh.GetTabBorders( aSet );
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!");
pDlg = pFact->CreateSwBorderDlg( pMDI, aSet, SW_BORDER_MODE_TABLE, RC_DLG_SWBORDERDLG );
DBG_ASSERT(pDlg, "Dialogdiet fail!");
if ( pDlg->Execute() == RET_OK )
{
rSh.SetTabBorders( *pDlg->GetOutputItemSet() );
pOutSet = pDlg->GetOutputItemSet();
}
}
else if ( rSh.IsFrmSelected() )
{
// Umrandungsattribute ueber Frame-Manager setzen
SwFlyFrmAttrMgr aMgr( sal_False, &rSh, FRMMGR_TYPE_NONE );
aSet.Put( aMgr.GetAttrSet() );
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!");
pDlg = pFact->CreateSwBorderDlg( pMDI, aSet, SW_BORDER_MODE_FRAME, RC_DLG_SWBORDERDLG );
DBG_ASSERT(pDlg, "Dialogdiet fail!");
if ( pDlg->Execute() == RET_OK )
{
aMgr.SetAttrSet( *pDlg->GetOutputItemSet() );
aMgr.UpdateFlyFrm();
pOutSet = pDlg->GetOutputItemSet();
}
}
else
{
// Umrandungsattribute ganz normal ueber Shell setzen
rSh.GetCurAttr( aSet );
::PrepareBoxInfo( aSet, rSh );
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!");
pDlg = pFact->CreateSwBorderDlg( pMDI, aSet, SW_BORDER_MODE_PARA, RC_DLG_SWBORDERDLG );
DBG_ASSERT(pDlg, "Dialogdiet fail!");
if ( pDlg->Execute() == RET_OK )
{
rSh.SetAttrSet( *pDlg->GetOutputItemSet() );
pOutSet = pDlg->GetOutputItemSet();
}
}
if(pOutSet)
{
rReq.Done(*pOutSet);
bDone = true;
}
delete pDlg;
}
break;
case FN_FORMAT_BACKGROUND_DLG:
{
SfxItemSet aSet( rSh.GetAttrPool(),
RES_BACKGROUND, RES_BACKGROUND );
SfxAbstractDialog * pDlg = 0;
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!");
// Tabellenzelle(n) selektiert?
if ( rSh.IsTableMode() )
{
//Hintergrundattribute der Tabelle holen und in den Set packen
SvxBrushItem aBrush(RES_BACKGROUND);
rSh.GetBoxBackground( aBrush );
pDlg = pFact->CreateSfxDialog( pMDI, aSet,
rView.GetViewFrame()->GetFrame().GetFrameInterface(),
RC_SWDLG_BACKGROUND );
DBG_ASSERT(pDlg, "Dialogdiet fail!");
aSet.Put( aBrush );
if ( pDlg->Execute() == RET_OK )
{
//aBrush = (SvxBrushItem) pDlg->GetOutputItemSet()->Get( RES_BACKGROUND );
rSh.SetBoxBackground( (SvxBrushItem&)
pDlg->GetOutputItemSet()->Get( RES_BACKGROUND ));
pOutSet = pDlg->GetOutputItemSet();
}
}
else if ( rSh.IsFrmSelected() )
{
rSh.GetFlyFrmAttr( aSet );
pDlg = pFact->CreateSfxDialog( pMDI, aSet,
rView.GetViewFrame()->GetFrame().GetFrameInterface(),
RC_SWDLG_BACKGROUND );
DBG_ASSERT(pDlg, "Dialogdiet fail!");
if ( pDlg->Execute() == RET_OK )
{
rSh.SetFlyFrmAttr((SfxItemSet &) *pDlg->GetOutputItemSet() );
pOutSet = pDlg->GetOutputItemSet();
}
}
else
{
// Umrandungsattribute ganz normal ueber Shell setzen
rSh.GetCurAttr( aSet );
pDlg = pFact->CreateSfxDialog( pMDI, aSet,
rView.GetViewFrame()->GetFrame().GetFrameInterface(),
RC_SWDLG_BACKGROUND );
DBG_ASSERT(pDlg, "Dialogdiet fail!");
if ( pDlg->Execute() == RET_OK )
{
rSh.SetAttrSet( *pDlg->GetOutputItemSet() );
pOutSet = pDlg->GetOutputItemSet();
}
}
if(pOutSet)
{
rReq.Done(*pOutSet);
bDone = true;
}
delete pDlg;
}
break;
default:DBG_ERROR("falscher Dispatcher (basesh.cxx)");
}
if(!bDone)
rReq.Done();
}
// ----------------------------------------------------------------------------
SwWrtShell& SwBaseShell::GetShell()
{
return rView.GetWrtShell();
}
// ----------------------------------------------------------------------------
SwWrtShell* SwBaseShell::GetShellPtr()
{
return rView.GetWrtShellPtr();
}
// ----------------------------------------------------------------------------
void SwBaseShell::InsertTable( SfxRequest& _rRequest )
{
const SfxItemSet* pArgs = _rRequest.GetArgs();
SwWrtShell& rSh = GetShell();
if ( !( rSh.GetFrmType( 0, sal_True ) & FRMTYPE_FOOTNOTE ) )
{
SwView &rTempView = GetView(); // Da GetView() nach Shellwechsel nicht mehr geht
sal_Bool bHTMLMode = 0 != (::GetHtmlMode(rTempView.GetDocShell())&HTMLMODE_ON);
sal_Bool bCallEndUndo = sal_False;
if( !pArgs && rSh.IsSelection() && !rSh.IsInClickToEdit() &&
!rSh.IsTableMode() )
{
const SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
SwInsertTableOptions aInsTblOpts = pModOpt->GetInsTblFlags(bHTMLMode);
rSh.StartUndo(UNDO_INSTABLE);
bCallEndUndo = sal_True;
sal_Bool bInserted = rSh.TextToTable( aInsTblOpts, '\t', text::HoriOrientation::FULL );
rSh.EnterStdMode();
if (bInserted)
rTempView.AutoCaption(TABLE_CAP);
_rRequest.Done();
}
else
{
sal_uInt16 nCols = 0;
sal_uInt16 nRows = 0;
SwInsertTableOptions aInsTblOpts( tabopts::ALL_TBL_INS_ATTR, 1 );
String aTableName, aAutoName;
SwTableAutoFmt* pTAFmt = 0;
if( pArgs && pArgs->Count() >= 2 )
{
SFX_REQUEST_ARG( _rRequest, pName, SfxStringItem, FN_INSERT_TABLE, sal_False );
SFX_REQUEST_ARG( _rRequest, pCols, SfxUInt16Item, SID_ATTR_TABLE_COLUMN, sal_False );
SFX_REQUEST_ARG( _rRequest, pRows, SfxUInt16Item, SID_ATTR_TABLE_ROW, sal_False );
SFX_REQUEST_ARG( _rRequest, pFlags, SfxInt32Item, FN_PARAM_1, sal_False );
SFX_REQUEST_ARG( _rRequest, pAuto, SfxStringItem, FN_PARAM_2, sal_False );
if ( pName )
aTableName = pName->GetValue();
if ( pCols )
nCols = pCols->GetValue();
if ( pRows )
nRows = pRows->GetValue();
if ( pAuto )
{
aAutoName = pAuto->GetValue();
if ( aAutoName.Len() )
{
SwTableAutoFmtTbl aTableTbl;
aTableTbl.Load();
for ( sal_uInt16 n=0; n<aTableTbl.Count(); n++ )
{
if ( aTableTbl[n]->GetName() == aAutoName )
{
pTAFmt = new SwTableAutoFmt( *aTableTbl[n] );
break;
}
}
}
}
if ( pFlags )
aInsTblOpts.mnInsMode = (sal_uInt16) pFlags->GetValue();
else
{
const SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
aInsTblOpts = pModOpt->GetInsTblFlags(bHTMLMode);
}
}
if( !nCols || !nRows )
{
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
DBG_ASSERT(pFact, "Dialogdiet fail!");
AbstractInsTableDlg* pDlg = pFact->CreateInsTableDlg( DLG_INSERT_TABLE, rTempView );
DBG_ASSERT(pDlg, "Dialogdiet fail!");
if( RET_OK == pDlg->Execute() )
{
pDlg->GetValues( aTableName, nRows, nCols, aInsTblOpts, aAutoName, pTAFmt );
}
else
_rRequest.Ignore();
delete pDlg;
}
if( nCols && nRows )
{
// record before shell change
_rRequest.AppendItem( SfxStringItem( FN_INSERT_TABLE, aTableName ) );
if ( aAutoName.Len() )
_rRequest.AppendItem( SfxStringItem( FN_PARAM_2, aAutoName ) );
_rRequest.AppendItem( SfxUInt16Item( SID_ATTR_TABLE_COLUMN, nCols ) );
_rRequest.AppendItem( SfxUInt16Item( SID_ATTR_TABLE_ROW, nRows ) );
_rRequest.AppendItem( SfxInt32Item( FN_PARAM_1, (sal_Int32) aInsTblOpts.mnInsMode ) );
_rRequest.Done();
rSh.StartUndo(UNDO_INSTABLE);
bCallEndUndo = sal_True;
rSh.StartAllAction();
if( rSh.HasSelection() )
rSh.DelRight();
rSh.InsertTable( aInsTblOpts, nRows, nCols, text::HoriOrientation::FULL, pTAFmt );
rSh.MoveTable( fnTablePrev, fnTableStart );
if( aTableName.Len() && !rSh.GetTblStyle( aTableName ) )
rSh.GetTableFmt()->SetName( aTableName );
rSh.EndAllAction();
rTempView.AutoCaption(TABLE_CAP);
}
delete pTAFmt;
}
if( bCallEndUndo )
{
SwRewriter aRewriter;
if (rSh.GetTableFmt())
{
aRewriter.AddRule(UNDO_ARG1, SW_RES(STR_START_QUOTE));
aRewriter.AddRule(UNDO_ARG2, rSh.GetTableFmt()->GetName());
aRewriter.AddRule(UNDO_ARG3, SW_RES(STR_END_QUOTE));
}
rSh.EndUndo(UNDO_INSTABLE, &aRewriter); // wegen moegl. Shellwechsel
}
}
}
// ----------------------------------------------------------------------------
void SwBaseShell::GetGalleryState( SfxItemSet &rSet )
{
SwWrtShell &rSh = GetShell();
SfxWhichIter aIter( rSet );
sal_uInt16 nWhich = aIter.FirstWhich();
switch ( nWhich )
{
case SID_GALLERY_BG_BRUSH:
{
int nSel = rSh.GetSelectionType();
SfxStringListItem aLst( nWhich );
List *pLst = aLst.GetList();
nParagraphPos = nGraphicPos = nOlePos = nFramePos = nTablePos =
nTableRowPos = nTableCellPos = nPagePos =
nHeaderPos = nFooterPos = 0;
sal_uInt8 nPos = 1;
pLst->Insert( (void*) new SW_RESSTR( STR_SWBG_PAGE ), pLst->Count() );
nPagePos = nPos++;
sal_uInt16 nHtmlMode = ::GetHtmlMode(GetView().GetDocShell());
sal_Bool bHtmlMode = 0 != (nHtmlMode & HTMLMODE_ON);
if ( (!bHtmlMode || (nHtmlMode & HTMLMODE_FULL_STYLES)) &&
(nSel & nsSelectionType::SEL_TXT) )
{
pLst->Insert( (void*) new SW_RESSTR( STR_SWBG_PARAGRAPH ), pLst->Count() );
nParagraphPos = nPos++;
}
if ( (!bHtmlMode || (nHtmlMode & HTMLMODE_SOME_STYLES)) &&
nSel & (nsSelectionType::SEL_TBL|nsSelectionType::SEL_TBL_CELLS) )
{
pLst->Insert( (void*) new SW_RESSTR( STR_SWBG_TABLE ), pLst->Count() );
nTablePos = nPos++;
if(!bHtmlMode)
{
pLst->Insert( (void*) new SW_RESSTR( STR_SWBG_TABLE_ROW ), pLst->Count() );
nTableRowPos = nPos++;
}
pLst->Insert( (void*) new SW_RESSTR( STR_SWBG_TABLE_CELL), pLst->Count() );
nTableCellPos = nPos++;
}
if(!bHtmlMode)
{
if ( nSel & nsSelectionType::SEL_FRM )
{
pLst->Insert( (void*) new SW_RESSTR( STR_SWBG_FRAME ), pLst->Count() );
nFramePos = nPos++;
}
if ( nSel & nsSelectionType::SEL_GRF )
{
pLst->Insert( (void*) new SW_RESSTR( STR_SWBG_GRAPHIC ), pLst->Count() );
nGraphicPos = nPos++;
}
if ( nSel & nsSelectionType::SEL_OLE )
{
pLst->Insert( (void*) new SW_RESSTR( STR_SWBG_OLE ), pLst->Count() );
nOlePos = nPos++;
}
const sal_uInt16 nType = rSh.GetFrmType(0,sal_True);
if ( nType & FRMTYPE_HEADER )
{
pLst->Insert( (void*) new SW_RESSTR( STR_SWBG_HEADER ), pLst->Count() );
nHeaderPos = nPos++;
}
if ( nType & FRMTYPE_FOOTER )
{
pLst->Insert( (void*) new SW_RESSTR( STR_SWBG_FOOTER ), pLst->Count() );
nFooterPos = nPos;
}
}
if ( pLst->Count() )
rSet.Put( aLst );
else
rSet.DisableItem( nWhich );
break;
}
}
}
void SwBaseShell::ExecuteGallery(SfxRequest &rReq)
{
SwWrtShell &rSh = GetShell();
rSh.StartAction();
const SfxItemSet* pArgs = rReq.GetArgs();
sal_uInt16 nSlot = rReq.GetSlot();
switch(nSlot)
{
case SID_GALLERY_BG_BRUSH:
{
if ( !pArgs )
break;
int nSel = rSh.GetSelectionType();
if ( nSel & nsSelectionType::SEL_DRW_TXT )
break;
SFX_REQUEST_ARG( rReq, pPos, SfxUInt16Item, SID_GALLERY_BG_POS, sal_False );
SFX_REQUEST_ARG( rReq, pBrush, SvxBrushItem, SID_GALLERY_BG_BRUSH, sal_False );
if ( !pPos || !pBrush )
break;
sal_uInt8 nPos = pPos->GetValue();
++nPos;
SvxBrushItem aBrush( *pBrush );
aBrush.SetWhich( RES_BACKGROUND );
if ( nPos == nParagraphPos )
rSh.SetAttrItem( aBrush );
else if ( nPos == nTablePos )
rSh.SetTabBackground( aBrush );
else if ( nPos == nTableRowPos )
rSh.SetRowBackground( aBrush );
else if ( nPos == nTableCellPos )
rSh.SetBoxBackground( aBrush );
else if ( nPos == nFramePos || nPos == nGraphicPos || nPos == nOlePos )
{
SfxItemSet aCoreSet(GetPool(), RES_BACKGROUND, RES_BACKGROUND);
aCoreSet.Put( aBrush );
rSh.SetFlyFrmAttr( aCoreSet );
}
else if ( nPos == nPagePos || nPos == nHeaderPos || nPos == nFooterPos )
{
sal_uInt16 nDesc = rSh.GetCurPageDesc();
SwPageDesc aDesc( rSh.GetPageDesc( nDesc ) );
if ( nPos == nPagePos )
aDesc.GetMaster().SetFmtAttr( aBrush );
else if ( nPos == nHeaderPos )
{
SwFmtHeader aHead( aDesc.GetMaster().GetHeader() );
aHead.GetHeaderFmt()->SetFmtAttr( aBrush );
aDesc.GetMaster().SetFmtAttr( aHead );
}
else if ( nPos == nFooterPos )
{
SwFmtFooter aFoot( aDesc.GetMaster().GetFooter() );
aFoot.GetFooterFmt()->SetFmtAttr( aBrush );
aDesc.GetMaster().SetFmtAttr( aFoot );
}
rSh.ChgPageDesc( nDesc, aDesc );
}
break;
}
}
rSh.EndAction();
rReq.Done();
}
void SwBaseShell::ExecField( SfxRequest& rReq )
{
sal_uInt16 nSlot = rReq.GetSlot();
switch( nSlot )
{
case FN_CHANGE_DBFIELD:
{
SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!");
VclAbstractDialog* pDlg = pFact->CreateSwChangeDBDlg(GetView(), DLG_CHANGE_DB );
DBG_ASSERT(pDlg, "Dialogdiet fail!");
pDlg->Execute();
delete pDlg;
}
break;
default:
ASSERT(sal_False, falscher Dispatcher);
}
}