xref: /aoo41x/main/sw/source/ui/shells/drwbassh.cxx (revision cb0cd92e)

/**************************************************************
 *
 * 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 <tools/shl.hxx>
#include <hintids.hxx>
#include <helpid.h>
#include <swtypes.hxx>
#include <sfx2/objface.hxx>
#include <sfx2/request.hxx>
#include <sfx2/bindings.hxx>
#include <svl/aeitem.hxx>
#include <svx/svdview.hxx>
#include <vcl/msgbox.hxx>
#include <svl/srchitem.hxx>
#include <svl/whiter.hxx>
#include <svx/swframevalidation.hxx>
#include <svx/anchorid.hxx>
#include <svx/htmlmode.hxx>
#include <uitool.hxx>
#include <fmtornt.hxx>
#include <cmdid.h>
#include <swmodule.hxx>
#include <wrtsh.hxx>
#include <wview.hxx>
#include <edtwin.hxx>
#include <viewopt.hxx>
#include <dcontact.hxx>
#include <frmfmt.hxx>
#include <wrap.hxx>
#include <drawbase.hxx>
#include <drwbassh.hxx>
#include <swdtflvr.hxx>
#include <svx/svdogrp.hxx>
#include <svx/svdpage.hxx>
#include <svx/svditer.hxx>

#include <shells.hrc>
#define SwDrawBaseShell
#include <sfx2/msg.hxx>
#include <swslots.hxx>
#include <svx/svxdlg.hxx>
#include <svx/dialogs.hrc>
#include "swabstdlg.hxx"
#include "dialog.hrc"
#include <swundo.hxx>
#include <com/sun/star/text/HoriOrientation.hpp>
#include <com/sun/star/text/VertOrientation.hpp>
#include <com/sun/star/text/RelOrientation.hpp>

#include <IDocumentDrawModelAccess.hxx>

using namespace ::com::sun::star;

SFX_IMPL_INTERFACE(SwDrawBaseShell, SwBaseShell, SW_RES(0))
{
}

TYPEINIT1(SwDrawBaseShell,SwBaseShell)

/*--------------------------------------------------------------------
	Beschreibung:
 --------------------------------------------------------------------*/


SwDrawBaseShell::SwDrawBaseShell(SwView &_rView):
    SwBaseShell( _rView )
{
	GetShell().NoEdit(sal_True);

	SwEditWin& rWin = GetView().GetEditWin();

	rWin.SetBezierMode(SID_BEZIER_MOVE);

    if ( !_rView.GetDrawFuncPtr() )
        _rView.GetEditWin().StdDrawMode( OBJ_NONE, sal_True );

	SwTransferable::CreateSelection( GetShell() );
}

/*--------------------------------------------------------------------
	Beschreibung:
 --------------------------------------------------------------------*/


SwDrawBaseShell::~SwDrawBaseShell()
{
	GetView().ExitDraw();
	GetShell().Edit();
	SwTransferable::ClearSelection( GetShell() );
}

/*--------------------------------------------------------------------
	Beschreibung:
 --------------------------------------------------------------------*/


void SwDrawBaseShell::Execute(SfxRequest &rReq)
{
	SwWrtShell *pSh = &GetShell();
	SdrView*	pSdrView = pSh->GetDrawView();
	const SfxItemSet *pArgs = rReq.GetArgs();
	sal_uInt16		nSlotId = rReq.GetSlot();
	sal_Bool		bChanged = pSdrView->GetModel()->IsChanged();
	pSdrView->GetModel()->SetChanged(sal_False);
	const SfxPoolItem* pItem = 0;
	if(pArgs)
		pArgs->GetItemState(nSlotId, sal_False, &pItem);

	//Sonderfall Align per Menue
	if(pItem && nSlotId == SID_OBJECT_ALIGN)
	{
		DBG_ASSERT(PTR_CAST(SfxEnumItem, pItem),"SfxEnumItem erwartet");
        nSlotId = nSlotId + ((const SfxEnumItem*)pItem)->GetValue();
		nSlotId++;
	}

	sal_Bool bAlignPossible = pSh->IsAlignPossible();

	sal_Bool bTopParam = sal_True, bBottomParam = sal_True;
	sal_Bool bNotify = sal_False;
	sal_Bool bDone = sal_False;
	SfxBindings& rBind = GetView().GetViewFrame()->GetBindings();

	switch (nSlotId)
	{
		case FN_DRAW_WRAP_DLG:
		{
			if(pSdrView->AreObjectsMarked())
			{
				if(!pArgs)
				{
					const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
					if( rMarkList.GetMark(0) != 0 )
					{
						SfxItemSet aSet(GetPool(),	RES_SURROUND, RES_SURROUND,
													RES_ANCHOR, RES_ANCHOR,
													RES_LR_SPACE, RES_UL_SPACE,
													SID_HTML_MODE, SID_HTML_MODE,
													FN_DRAW_WRAP_DLG, FN_DRAW_WRAP_DLG,
													0);

						aSet.Put(SfxBoolItem(SID_HTML_MODE,
							0 != ::GetHtmlMode(pSh->GetView().GetDocShell())));

						aSet.Put(SfxInt16Item(FN_DRAW_WRAP_DLG, pSh->GetLayerId()));

						pSh->GetObjAttr(aSet);
                        SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
                        DBG_ASSERT(pFact, "SwAbstractDialogFactory fail!");

                        SfxAbstractDialog* pDlg = pFact->CreateSwWrapDlg( GetView().GetWindow(), aSet, pSh, sal_True, RC_DLG_SWWRAPDLG );
                        DBG_ASSERT(pDlg, "Dialogdiet fail!");

                        if (pDlg->Execute() == RET_OK)
						{
                            const SfxPoolItem* pWrapItem;
                            const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
                            if(SFX_ITEM_SET == pOutSet->GetItemState(FN_DRAW_WRAP_DLG, sal_False, &pWrapItem))
							{
                                short nLayer = ((const SfxInt16Item*)pWrapItem)->GetValue();
								if (nLayer == 1)
									pSh->SelectionToHeaven();
								else
									pSh->SelectionToHell();
							}

							pSh->SetObjAttr(*pOutSet);
						}
                    delete pDlg;
					}
				}
			}
		}
		break;

		case SID_ATTR_TRANSFORM:
		{
			if(pSdrView->AreObjectsMarked())
			{
				if(!pArgs)
				{
					const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
					if( rMarkList.GetMark(0) != 0 )
					{
						SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
                        SfxAbstractTabDialog *pDlg=NULL;
						sal_Bool bCaption = sal_False;

						// Erlaubte Verankerungen:
                        short nAnchor = pSh->GetAnchorId();
						sal_uInt16 nAllowedAnchors = SVX_OBJ_AT_CNTNT|SVX_OBJ_IN_CNTNT;
						sal_uInt16 nHtmlMode = ::GetHtmlMode(pSh->GetView().GetDocShell());

                        if( !((HTMLMODE_ON & nHtmlMode) && (0 == (nHtmlMode & HTMLMODE_SOME_ABS_POS))) )
							nAllowedAnchors |= SVX_OBJ_PAGE;
						if ( pSh->IsFlyInFly() )
							nAllowedAnchors |= SVX_OBJ_AT_FLY;

						if (pObj->GetObjIdentifier() == OBJ_CAPTION )
							bCaption = sal_True;

						if (bCaption)
                        {
							SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
							if ( pFact )
							{
                                AbstractSvxCaptionDialog* pCaptionDlg =
                                        pFact->CreateCaptionDialog( NULL, pSdrView, nAllowedAnchors );
                                pCaptionDlg->SetValidateFramePosLink( LINK(this, SwDrawBaseShell, ValidatePosition) );
                                pDlg = pCaptionDlg;
                                DBG_ASSERT(pDlg, "Dialogdiet fail!");
							}
						}
						else
						{
							SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
							if ( pFact )
							{

                                AbstractSvxTransformTabDialog* pTransform =
                                            pFact->CreateSvxTransformTabDialog( NULL, NULL, pSdrView, nAllowedAnchors );
                                pTransform->SetValidateFramePosLink( LINK(this, SwDrawBaseShell, ValidatePosition) );
                                pDlg = pTransform;
                                DBG_ASSERT(pDlg, "Dialogdiet fail!");
							}
						}
						SfxItemSet aNewAttr(pSdrView->GetGeoAttrFromMarked());

						const sal_uInt16* pRange = pDlg->GetInputRanges( *aNewAttr.GetPool() );
						SfxItemSet aSet( *aNewAttr.GetPool(), pRange );
                        FieldUnit eMetric = ::GetDfltMetric(0 != dynamic_cast<SwWebView*>(&GetView()));
                        SW_MOD()->PutItem(SfxUInt16Item(SID_ATTR_METRIC, static_cast< sal_uInt16 >(eMetric)) );

						aSet.Put( aNewAttr, sal_False );

						if (bCaption)
							pSdrView->GetAttributes( aSet );

                        aSet.Put(SfxInt16Item(SID_ATTR_TRANSFORM_ANCHOR, nAnchor));
                        sal_Bool bRTL;
                        sal_Bool bVertL2R;
                        aSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_IN_VERTICAL_TEXT, pSh->IsFrmVertical(sal_True, bRTL, bVertL2R)));
                        aSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_IN_RTL_TEXT, bRTL));

                        SwFrmFmt* pFrmFmt = FindFrmFmt( pObj );

                        aSet.Put( pFrmFmt->GetFmtAttr(RES_FOLLOW_TEXT_FLOW) );

                        SwFmtVertOrient aVOrient((const SwFmtVertOrient&)pFrmFmt->GetFmtAttr(RES_VERT_ORIENT));
                        aSet.Put(SfxInt16Item(SID_ATTR_TRANSFORM_VERT_ORIENT, aVOrient.GetVertOrient()));
                        aSet.Put(SfxInt16Item(SID_ATTR_TRANSFORM_VERT_RELATION, aVOrient.GetRelationOrient() ));
                        aSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_VERT_POSITION, aVOrient.GetPos()));

                        SwFmtHoriOrient aHOrient((const SwFmtHoriOrient&)pFrmFmt->GetFmtAttr(RES_HORI_ORIENT));
                        aSet.Put(SfxInt16Item(SID_ATTR_TRANSFORM_HORI_ORIENT, aHOrient.GetHoriOrient()));
                        aSet.Put(SfxInt16Item(SID_ATTR_TRANSFORM_HORI_RELATION, aHOrient.GetRelationOrient() ));
                        aSet.Put(SfxBoolItem(SID_ATTR_TRANSFORM_HORI_MIRROR, aHOrient.IsPosToggle()));
                        aSet.Put(SfxInt32Item(SID_ATTR_TRANSFORM_HORI_POSITION, aHOrient.GetPos()));

                        aSet.Put(SfxUInt16Item(SID_HTML_MODE, nHtmlMode));

						pDlg->SetInputSet( &aSet );

						if (pDlg->Execute() == RET_OK)
						{
							const SfxItemSet* pOutSet = pDlg->GetOutputItemSet();
							pSh->StartAllAction();

                            // --> OD 2004-07-14 #i30451#
                            pSh->StartUndo(UNDO_INSFMTATTR);

                            pSdrView->SetGeoAttrToMarked(*pOutSet);

							if (bCaption)
								pSdrView->SetAttributes(*pOutSet);

							sal_Bool bPosCorr =
								SFX_ITEM_SET != pOutSet->GetItemState(
									SID_ATTR_TRANSFORM_POS_X, sal_False ) &&
								SFX_ITEM_SET != pOutSet->GetItemState(
									SID_ATTR_TRANSFORM_POS_Y, sal_False );

                            SfxItemSet aFrmAttrSet(GetPool(), RES_FRMATR_BEGIN, RES_FRMATR_END - 1);

                            bool bSingleSelection = rMarkList.GetMarkCount() == 1;

                            const SfxPoolItem* pAnchorItem;
                            if(SFX_ITEM_SET == pOutSet->GetItemState(
                                SID_ATTR_TRANSFORM_ANCHOR, sal_False, &pAnchorItem))
                            {
                                if(!bSingleSelection)
                                    pSh->ChgAnchor(((const SfxInt16Item*)pAnchorItem)
                                            ->GetValue(), sal_False, bPosCorr );
                                else
                                {
                                    SwFmtAnchor aAnchor(pFrmFmt->GetAnchor());
                                    aAnchor.SetType((RndStdIds)((const SfxInt16Item*)pAnchorItem)->GetValue());
                                    aFrmAttrSet.Put( aAnchor );
                                }
                            }
                            const SfxPoolItem* pHoriOrient = 0;
                            const SfxPoolItem* pHoriRelation = 0;
                            const SfxPoolItem* pHoriPosition = 0;
                            const SfxPoolItem* pHoriMirror = 0;
                            pOutSet->GetItemState(SID_ATTR_TRANSFORM_HORI_ORIENT, sal_False, &pHoriOrient);
                            pOutSet->GetItemState(SID_ATTR_TRANSFORM_HORI_RELATION, sal_False, &pHoriRelation);
                            pOutSet->GetItemState(SID_ATTR_TRANSFORM_HORI_POSITION, sal_False, &pHoriPosition);
                            pOutSet->GetItemState(SID_ATTR_TRANSFORM_HORI_MIRROR, sal_False, &pHoriMirror);
                            if(pHoriOrient || pHoriRelation || pHoriPosition || pHoriMirror)
                            {
                                if(pHoriOrient)
                                    aHOrient.SetHoriOrient(
                                          static_cast<const SfxInt16Item*>(pHoriOrient)->GetValue());
                                if(pHoriRelation)
                                    aHOrient.SetRelationOrient(
                                              static_cast<const SfxInt16Item*>(pHoriRelation)->GetValue());
                                if(pHoriPosition)
                                    aHOrient.SetPos( static_cast<const SfxInt32Item*>(pHoriPosition)->GetValue());
                                if(pHoriMirror)
                                    aHOrient.SetPosToggle( static_cast<const SfxBoolItem*>(pHoriMirror)->GetValue());
                                aFrmAttrSet.Put(aHOrient);
                            }

                            const SfxPoolItem* pVertOrient = 0;
                            const SfxPoolItem* pVertRelation = 0;
                            const SfxPoolItem* pVertPosition = 0;
                            pOutSet->GetItemState(SID_ATTR_TRANSFORM_VERT_ORIENT, sal_False, &pVertOrient);
                            pOutSet->GetItemState(SID_ATTR_TRANSFORM_VERT_RELATION, sal_False, &pVertRelation);
                            pOutSet->GetItemState(SID_ATTR_TRANSFORM_VERT_POSITION, sal_False, &pVertPosition);
                            if(pVertOrient || pVertRelation || pVertPosition )
                            {
                                if(pVertOrient)
                                    aVOrient.SetVertOrient(
                                        static_cast<const SfxInt16Item*>(pVertOrient)->GetValue());
                                if(pVertRelation)
                                    aVOrient.SetRelationOrient(
                                        static_cast<const SfxInt16Item*>(pVertRelation)->GetValue());
                                if(pVertPosition)
                                    aVOrient.SetPos( static_cast<const SfxInt32Item*>(pVertPosition)->GetValue());
                                aFrmAttrSet.Put( aVOrient );
                            }
                            const SfxPoolItem* pFollowItem = 0;
                            pOutSet->GetItemState(RES_FOLLOW_TEXT_FLOW, sal_False, &pFollowItem);
                            if(pFollowItem)
                                aFrmAttrSet.Put(*pFollowItem);

                            if(aFrmAttrSet.Count())
                                pSh->SetDrawingAttr(aFrmAttrSet);

							rBind.InvalidateAll(sal_False);

                            // --> OD 2004-07-14 #i30451#
                            pSh->EndUndo( UNDO_INSFMTATTR );

                            pSh->EndAllAction();
						}
						delete pDlg;

					}
				}
                else
                {
                    pSdrView->SetGeoAttrToMarked( *pArgs );
                }
			}
		}
		break;

		case SID_DELETE:
		case FN_BACKSPACE:
			if (pSh->IsObjSelected() && !pSdrView->IsTextEdit())
			{
				bDone = sal_True;

				if( GetView().IsDrawRotate() )
				{
					pSh->SetDragMode( SDRDRAG_MOVE );
					GetView().FlipDrawRotate();
				}

				pSh->SetModified();
				pSh->DelSelectedObj();

                if (rReq.IsAPI() ||
                    GetView().GetEditWin().IsObjectSelect() )
				{
                    // Wenn Basic-Aufruf, dann zurueck in die Textshell, da das
                    // Basic sonst keine Rueckkehrmoeglichkeit hat.
					if (GetView().GetDrawFuncPtr())
					{
						GetView().GetDrawFuncPtr()->Deactivate();
						GetView().SetDrawFuncPtr(NULL);
					}
					GetView().LeaveDrawCreate();	// In Selektionsmode wechseln
				}

				if (pSh->IsSelFrmMode())
				{
					pSh->LeaveSelFrmMode();
                    // #105852# FME
//                   pSh->NoEdit();
				}
				bNotify = sal_True;
			}
			break;

		case SID_GROUP:
			if (pSh->IsObjSelected() > 1 && pSh->IsGroupAllowed())
			{
				pSh->GroupSelection();	// Objekt gruppieren
				rBind.Invalidate(SID_UNGROUP);
			}
			break;

		case SID_UNGROUP:
			if (pSh->IsGroupSelected())
			{
				pSh->UnGroupSelection();	// Objektgruppierung aufheben
				rBind.Invalidate(SID_GROUP);
			}
			break;

		case SID_ENTER_GROUP:
			if (pSh->IsGroupSelected())
			{
				pSdrView->EnterMarkedGroup();
				rBind.InvalidateAll(sal_False);
			}
			break;

		case SID_LEAVE_GROUP:
			if (pSdrView->IsGroupEntered())
			{
				pSdrView->LeaveOneGroup();
				rBind.Invalidate(SID_ENTER_GROUP);
				rBind.Invalidate(SID_UNGROUP);
			}
			break;

		case SID_OBJECT_ALIGN_LEFT:
		case SID_OBJECT_ALIGN_CENTER:
		case SID_OBJECT_ALIGN_RIGHT:
		case SID_OBJECT_ALIGN_UP:
		case SID_OBJECT_ALIGN_MIDDLE:
		case SID_OBJECT_ALIGN_DOWN:
		{
			if ( bAlignPossible )
			{
				const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
				if( rMarkList.GetMarkCount() == 1 && bAlignPossible )
				{	// Objekte nicht aneinander ausrichten

					sal_uInt16 nAnchor = pSh->GetAnchorId();
                    if (nAnchor == FLY_AS_CHAR)
                    {
                        sal_Int16 nVertOrient = -1;

						switch (nSlotId)
						{
							case SID_OBJECT_ALIGN_UP:
                                nVertOrient = text::VertOrientation::TOP;
								break;
							case SID_OBJECT_ALIGN_MIDDLE:
                                nVertOrient = text::VertOrientation::CENTER;
								break;
							case SID_OBJECT_ALIGN_DOWN:
                                nVertOrient = text::VertOrientation::BOTTOM;
								break;
							default:
								break;
						}
						if (nVertOrient != -1)
						{
							pSh->StartAction();
							SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
							SwFrmFmt* pFrmFmt = FindFrmFmt( pObj );
                            SwFmtVertOrient aVOrient((SwFmtVertOrient&)pFrmFmt->GetFmtAttr(RES_VERT_ORIENT));
                            aVOrient.SetVertOrient( nVertOrient );
                            pFrmFmt->SetFmtAttr(aVOrient);
							pSh->EndAction();
						}
						break;
                    }
                    if (nAnchor == FLY_AT_PARA)
						break;	// Absatzverankerte Rahmen nicht ausrichten
				}

				pSh->StartAction();
				switch (nSlotId)
				{
					case SID_OBJECT_ALIGN_LEFT:
						pSdrView->AlignMarkedObjects(SDRHALIGN_LEFT, SDRVALIGN_NONE);
						break;
					case SID_OBJECT_ALIGN_CENTER:
						pSdrView->AlignMarkedObjects(SDRHALIGN_CENTER, SDRVALIGN_NONE);
						break;
					case SID_OBJECT_ALIGN_RIGHT:
						pSdrView->AlignMarkedObjects(SDRHALIGN_RIGHT, SDRVALIGN_NONE);
						break;
					case SID_OBJECT_ALIGN_UP:
						pSdrView->AlignMarkedObjects(SDRHALIGN_NONE, SDRVALIGN_TOP);
						break;
					case SID_OBJECT_ALIGN_MIDDLE:
						pSdrView->AlignMarkedObjects(SDRHALIGN_NONE, SDRVALIGN_CENTER);
						break;
					case SID_OBJECT_ALIGN_DOWN:
						pSdrView->AlignMarkedObjects(SDRHALIGN_NONE, SDRVALIGN_BOTTOM);
						break;
				}
				pSh->EndAction();
			}
		}
		break;

		case FN_FRAME_UP:
			bTopParam = sal_False;
			/* no break */
		case SID_FRAME_TO_TOP:
			pSh->SelectionToTop( bTopParam );
			break;

		case FN_FRAME_DOWN:
			bBottomParam = sal_False;
			/* no break */
		case SID_FRAME_TO_BOTTOM:
			pSh->SelectionToBottom( bBottomParam );
			break;

		case FN_NAME_SHAPE:
		{
            bDone = sal_True;

			if(1L == pSdrView->GetMarkedObjectCount())
			{
				// #i68101#
				SdrObject* pSelected = pSdrView->GetMarkedObjectByIndex(0L);
				OSL_ENSURE(pSelected, "DrawViewShell::FuTemp03: nMarkCount, but no object (!)");
				String aName(pSelected->GetName());

				SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
				OSL_ENSURE(pFact, "Dialogdiet fail!");
				AbstractSvxObjectNameDialog* pDlg = pFact->CreateSvxObjectNameDialog(NULL, aName);
				OSL_ENSURE(pDlg, "Dialogdiet fail!");

	            pDlg->SetCheckNameHdl(LINK(this, SwDrawBaseShell, CheckGroupShapeNameHdl));

				if(RET_OK == pDlg->Execute())
				{
					pDlg->GetName(aName);
					pSelected->SetName(aName);
					pSh->SetModified();
				}

				delete pDlg;
			}

			break;
		}

		// #i68101#
		case FN_TITLE_DESCRIPTION_SHAPE:
		{
            bDone = sal_True;

			if(1L == pSdrView->GetMarkedObjectCount())
			{
				SdrObject* pSelected = pSdrView->GetMarkedObjectByIndex(0L);
				OSL_ENSURE(pSelected, "DrawViewShell::FuTemp03: nMarkCount, but no object (!)");
				String aTitle(pSelected->GetTitle());
				String aDescription(pSelected->GetDescription());

				SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
				OSL_ENSURE(pFact, "Dialogdiet fail!");
				AbstractSvxObjectTitleDescDialog* pDlg = pFact->CreateSvxObjectTitleDescDialog(NULL, aTitle, aDescription);
				OSL_ENSURE(pDlg, "Dialogdiet fail!");

				if(RET_OK == pDlg->Execute())
				{
					pDlg->GetTitle(aTitle);
					pDlg->GetDescription(aDescription);

					pSelected->SetTitle(aTitle);
					pSelected->SetDescription(aDescription);

					pSh->SetModified();
				}

				delete pDlg;
			}

			break;
		}

		default:
			DBG_ASSERT(!this, "falscher Dispatcher");
			return;
	}
	if(!bDone)
	{
		if(nSlotId >= SID_OBJECT_ALIGN_LEFT && nSlotId <= SID_OBJECT_ALIGN_DOWN)
			rBind.Invalidate(SID_ATTR_LONG_LRSPACE);
		if (pSdrView->GetModel()->IsChanged())
			pSh->SetModified();
		else if (bChanged)
			pSdrView->GetModel()->SetChanged(sal_True);
		// 40220: Nach dem Loeschen von DrawObjekten ueber die API GPF durch Selbstzerstoerung
		if(bNotify)
			GetView().AttrChangedNotify(pSh); // ggf Shellwechsel...
	}
}
/* -----------------------------27.02.2002 15:27------------------------------
    Checks whether a given name is allowed for a group shape
 ---------------------------------------------------------------------------*/
IMPL_LINK( SwDrawBaseShell, CheckGroupShapeNameHdl, AbstractSvxNameDialog*, pNameDialog )
{
    SwWrtShell          &rSh = GetShell();
    SdrView *pSdrView = rSh.GetDrawView();
    const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
    DBG_ASSERT(rMarkList.GetMarkCount() == 1, "wrong draw selection");
    SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
    const String sCurrentName = pObj->GetName();
    String sNewName;
    pNameDialog->GetName(sNewName);
    long nRet = 0;
    if(!sNewName.Len() || sCurrentName == sNewName)
        nRet = 1;
    else
    {
        nRet = 1;
        SdrModel* pModel = rSh.getIDocumentDrawModelAccess()->GetDrawModel();
        // --> OD 2006-03-09 #i51726# - all drawing objects can be named now.
        // consider also drawing objects inside group objects
//        SdrPage* pPage = pModel->GetPage(0);
//        sal_uInt32 nCount = pPage->GetObjCount();
//        for( sal_uInt32 i=0; i< nCount; i++ )
//        {
//            SdrObject* pTemp = pPage->GetObj(i);
//            if(pObj != pTemp && pTemp->ISA(SdrObjGroup) && pTemp->GetName() == sNewName)
//            {
//                nRet = 0;
//                break;
//            }
//        }
        SdrObjListIter aIter( *(pModel->GetPage(0)), IM_DEEPWITHGROUPS );
        while( aIter.IsMore() )
        {
            SdrObject* pTempObj = aIter.Next();
            if ( pObj != pTempObj && pTempObj->GetName() == sNewName )
            {
                nRet = 0;
                break;
            }
        }
        // <--
    }
    return nRet;
}
/*--------------------------------------------------------------------
	Beschreibung:
 --------------------------------------------------------------------*/
void SwDrawBaseShell::GetState(SfxItemSet& rSet)
{
	SwWrtShell &rSh = GetShell();
	SdrView* pSdrView = rSh.GetDrawViewWithValidMarkList();
	SfxWhichIter aIter( rSet );
	sal_uInt16 nWhich = aIter.FirstWhich();
	sal_Bool bProtected = rSh.IsSelObjProtected(FLYPROTECT_CONTENT);

	if (!bProtected)	// Im Parent nachsehen
		bProtected |= rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) != 0;

	while( nWhich )
	{
		switch( nWhich )
		{
			case FN_DRAW_WRAP_DLG:
			case SID_ATTR_TRANSFORM:
			case SID_FRAME_TO_TOP:
			case SID_FRAME_TO_BOTTOM:
			case FN_FRAME_UP:
			case FN_FRAME_DOWN:
			case SID_DELETE:
			case FN_BACKSPACE:
				if( bProtected || !rSh.IsObjSelected() )
					rSet.DisableItem( nWhich );
				break;
			case SID_GROUP:
				if ( rSh.IsObjSelected() < 2 || bProtected || !rSh.IsGroupAllowed() )
					rSet.DisableItem( nWhich );
				break;
			case SID_UNGROUP:
				if ( !rSh.IsGroupSelected() || bProtected )
					rSet.DisableItem( nWhich );
				break;
			case SID_ENTER_GROUP:
				if ( !rSh.IsGroupSelected() )
					rSet.DisableItem( nWhich );
				break;
			case SID_LEAVE_GROUP:
				if ( !pSdrView->IsGroupEntered() )
					rSet.DisableItem( nWhich );
				break;
			case SID_OBJECT_ALIGN_LEFT:
			case SID_OBJECT_ALIGN_CENTER:
			case SID_OBJECT_ALIGN_RIGHT:
			case SID_OBJECT_ALIGN_UP:
			case SID_OBJECT_ALIGN_MIDDLE:
			case SID_OBJECT_ALIGN_DOWN:
			case SID_OBJECT_ALIGN:
				if ( !rSh.IsAlignPossible() || bProtected )
					rSet.DisableItem( nWhich );
				else
				{
                    SfxAllEnumItem aEnumItem(nWhich, USHRT_MAX);
                    const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
                    //if only one object is selected it can only be vertically
                    // aligned because it is character bound
                    if( rMarkList.GetMarkCount() == 1 )
                    {
                        aEnumItem.DisableValue(SID_OBJECT_ALIGN_LEFT);
                        aEnumItem.DisableValue(SID_OBJECT_ALIGN_CENTER);
                        aEnumItem.DisableValue(SID_OBJECT_ALIGN_RIGHT);
                    }
                    rSet.Put(aEnumItem);
				}
				break;

			case FN_NAME_SHAPE :
				{
					if(1L != pSdrView->GetMarkedObjectCount())
					{
						rSet.DisableItem( nWhich );
					}
				}
				break;

			// #i68101#
			case FN_TITLE_DESCRIPTION_SHAPE:
				{
                    const bool bIsWebView(NULL != dynamic_cast<SwWebView*>(&GetView()));

					if(!bIsWebView && 1L != pSdrView->GetMarkedObjectCount())
					{
						rSet.DisableItem( nWhich );
					}
				}
				break;
        }
		nWhich = aIter.NextWhich();
	}
}


void SwDrawBaseShell::GetDrawAttrStateForIFBX( SfxItemSet& rSet )
{
 	SwWrtShell *pSh = &GetShell();
 	SdrView*	pSdrView = pSh->GetDrawView();
 	const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
 	if( rMarkList.GetMark(0) != 0 )
 	{
		// SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();//OST_IFBX@WL2
 		SfxItemSet aNewAttr(pSdrView->GetGeoAttrFromMarked());
 		rSet.Put(aNewAttr,false);
 	}
}


sal_Bool SwDrawBaseShell::Disable(SfxItemSet& rSet, sal_uInt16 nWhich)
{
	sal_Bool bDisable = GetShell().IsSelObjProtected(FLYPROTECT_CONTENT);

	if (bDisable)
	{
		if (nWhich)
			rSet.DisableItem( nWhich );
		else
		{
			SfxWhichIter aIter( rSet );
			nWhich = aIter.FirstWhich();
			while (nWhich)
			{
				rSet.DisableItem( nWhich );
				nWhich = aIter.NextWhich();
			}
		}
	}

	return bDisable;
}

/*-- 09.03.2004 13:15:03---------------------------------------------------
    Validate of drawing positions
  -----------------------------------------------------------------------*/
IMPL_LINK(SwDrawBaseShell, ValidatePosition, SvxSwFrameValidation*, pValidation )
{
    SwWrtShell *pSh = &GetShell();
    pValidation->nMinHeight = MINFLY;
    pValidation->nMinWidth =  MINFLY;

    SwRect aBoundRect;

    // OD 18.09.2003 #i18732# - adjustment for allowing vertical position
    //      aligned to page for fly frame anchored to paragraph or to character.
    const RndStdIds eAnchorType = static_cast<RndStdIds >(pValidation->nAnchorType);
    const SwPosition* pCntntPos = 0;
    SdrView*  pSdrView = pSh->GetDrawView();
    const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
    if( rMarkList.GetMarkCount() == 1 )
    {
        SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
        SwFrmFmt* pFrmFmt = FindFrmFmt( pObj );
        pCntntPos = pFrmFmt->GetAnchor().GetCntntAnchor();
    }

    pSh->CalcBoundRect( aBoundRect, eAnchorType,
                           pValidation->nHRelOrient,
                           pValidation->nVRelOrient,
                           pCntntPos,
                           pValidation->bFollowTextFlow,
                           pValidation->bMirror, NULL, &pValidation->aPercentSize);

    sal_Bool bIsInVertical( sal_False );
    {
        sal_Bool bRTL;
        sal_Bool bVertL2R;
        bIsInVertical = pSh->IsFrmVertical(sal_True, bRTL, bVertL2R);
    }
    if(bIsInVertical)
    {
        Point aPos(aBoundRect.Pos());
        long nTmp = aPos.X();
        aPos.X() = aPos.Y();
        aPos.Y() = nTmp;
        Size aSize(aBoundRect.SSize());
        nTmp = aSize.Width();
        aSize.Width() = aSize.Height();
        aSize.Height() = nTmp;
        aBoundRect.Chg( aPos, aSize );
        //exchange width/height to enable correct values
        nTmp = pValidation->nWidth;
        pValidation->nWidth = pValidation->nHeight;
        pValidation->nHeight = nTmp;
    }
    if ((eAnchorType == FLY_AT_PAGE) || (eAnchorType == FLY_AT_FLY))
    {
        // MinimalPosition
        pValidation->nMinHPos = aBoundRect.Left();
        pValidation->nMinVPos = aBoundRect.Top();
        SwTwips nH = pValidation->nHPos;
        SwTwips nV = pValidation->nVPos;

        if (pValidation->nHPos + pValidation->nWidth > aBoundRect.Right())
        {
            if (pValidation->nHoriOrient == text::HoriOrientation::NONE)
            {
                pValidation->nHPos -= ((pValidation->nHPos + pValidation->nWidth) - aBoundRect.Right());
                nH = pValidation->nHPos;
            }
            else
                pValidation->nWidth = aBoundRect.Right() - pValidation->nHPos;
        }

        if (pValidation->nHPos + pValidation->nWidth > aBoundRect.Right())
            pValidation->nWidth = aBoundRect.Right() - pValidation->nHPos;

        if (pValidation->nVPos + pValidation->nHeight > aBoundRect.Bottom())
        {
            if (pValidation->nVertOrient == text::VertOrientation::NONE)
            {
                pValidation->nVPos -= ((pValidation->nVPos + pValidation->nHeight) - aBoundRect.Bottom());
                nV = pValidation->nVPos;
            }
            else
                pValidation->nHeight = aBoundRect.Bottom() - pValidation->nVPos;
        }

        if (pValidation->nVPos + pValidation->nHeight > aBoundRect.Bottom())
            pValidation->nHeight = aBoundRect.Bottom() - pValidation->nVPos;

        if ( pValidation->nVertOrient != text::VertOrientation::NONE )
            nV = aBoundRect.Top();

        if ( pValidation->nHoriOrient != text::HoriOrientation::NONE )
            nH = aBoundRect.Left();

        pValidation->nMaxHPos   = aBoundRect.Right()  - pValidation->nWidth;
        pValidation->nMaxHeight = aBoundRect.Bottom() - nV;

        pValidation->nMaxVPos   = aBoundRect.Bottom() - pValidation->nHeight;
        pValidation->nMaxWidth  = aBoundRect.Right()  - nH;
    }
    else if ((eAnchorType == FLY_AT_PARA) || (eAnchorType == FLY_AT_CHAR))
    {
        if (pValidation->nHPos + pValidation->nWidth > aBoundRect.Right())
        {
            if (pValidation->nHoriOrient == text::HoriOrientation::NONE)
            {
                pValidation->nHPos -= ((pValidation->nHPos + pValidation->nWidth) - aBoundRect.Right());
            }
            else
                pValidation->nWidth = aBoundRect.Right() - pValidation->nHPos;
        }

        // OD 29.09.2003 #i17567#, #i18732# - consider following the text flow
        // and alignment at page areas.
        const bool bMaxVPosAtBottom = !pValidation->bFollowTextFlow ||
                                      pValidation->nVRelOrient == text::RelOrientation::PAGE_FRAME ||
                                      pValidation->nVRelOrient == text::RelOrientation::PAGE_PRINT_AREA;
        {
            SwTwips nTmpMaxVPos = ( bMaxVPosAtBottom
                                    ? aBoundRect.Bottom()
                                    : aBoundRect.Height() ) -
                                  pValidation->nHeight;
            if ( pValidation->nVPos > nTmpMaxVPos )
            {
                if (pValidation->nVertOrient == text::VertOrientation::NONE)
                {
                    pValidation->nVPos = nTmpMaxVPos;
                }
                else
                {
                    pValidation->nHeight = ( bMaxVPosAtBottom
                                     ? aBoundRect.Bottom()
                                     : aBoundRect.Height() ) - pValidation->nVPos;
                }
            }
        }

        pValidation->nMinHPos  = aBoundRect.Left();
        pValidation->nMaxHPos  = aBoundRect.Right() - pValidation->nWidth;

        pValidation->nMinVPos  = aBoundRect.Top();
        // OD 26.09.2003 #i17567#, #i18732# - determine maximum vertical position
        if ( bMaxVPosAtBottom )
        {
            pValidation->nMaxVPos  = aBoundRect.Bottom() - pValidation->nHeight;
        }
        else
        {
            pValidation->nMaxVPos  = aBoundRect.Height() - pValidation->nHeight;
        }

        // Maximale Breite Hoehe
        const SwTwips nH = ( pValidation->nHoriOrient != text::HoriOrientation::NONE )
                           ? aBoundRect.Left()
                           : pValidation->nHPos;
        const SwTwips nV = ( pValidation->nVertOrient != text::VertOrientation::NONE )
                           ? aBoundRect.Top()
                           : pValidation->nVPos;
        pValidation->nMaxHeight  = pValidation->nMaxVPos + pValidation->nHeight - nV;
        pValidation->nMaxWidth   = pValidation->nMaxHPos + pValidation->nWidth - nH;
    }
    else if (eAnchorType == FLY_AS_CHAR)
    {
        pValidation->nMinHPos = 0;
        pValidation->nMaxHPos = 0;

        pValidation->nMaxHeight = aBoundRect.Height();
        pValidation->nMaxWidth  = aBoundRect.Width();

        pValidation->nMaxVPos   = aBoundRect.Height();
        pValidation->nMinVPos   = -aBoundRect.Height() + pValidation->nHeight;
        if (pValidation->nMaxVPos < pValidation->nMinVPos)
        {
            pValidation->nMinVPos = pValidation->nMaxVPos;
            pValidation->nMaxVPos = -aBoundRect.Height();
        }
    }
    if(bIsInVertical)
    {
        //restore width/height exchange
        long nTmp = pValidation->nWidth;
        pValidation->nWidth = pValidation->nHeight;
        pValidation->nHeight = nTmp;
    }

    if (pValidation->nMaxWidth < pValidation->nWidth)
        pValidation->nWidth = pValidation->nMaxWidth;
    if (pValidation->nMaxHeight < pValidation->nHeight)
        pValidation->nHeight = pValidation->nMaxHeight;
    return 0;
}