xref: /AOO41X/main/sd/source/ui/view/sdview.cxx (revision edf077ab32c39bd8b569efe7eb2ca65482fb10cb)

/**************************************************************
 *
 * 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_sd.hxx"
#include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
#include <com/sun/star/linguistic2/XSpellChecker1.hpp>

#include "View.hxx"
#include <editeng/unolingu.hxx>
#include <sfx2/request.hxx>
#include <svx/obj3d.hxx>
#include <svx/fmview.hxx>
#include <editeng/outliner.hxx>
#ifndef _SVX_SVXIDS_HRC
#include <svx/svxids.hrc>
#endif
#include <svx/svdograf.hxx>
#include <svx/svdoole2.hxx>
#include <svx/svdundo.hxx>
#include <vcl/msgbox.hxx>
#include <sfx2/dispatch.hxx>
#include <sfx2/app.hxx>
#include <svx/svdpagv.hxx>
#include <sfx2/docfile.hxx>
#include <svx/svdoutl.hxx>
#include <svx/sdr/contact/displayinfo.hxx>

#include <svx/svdetc.hxx>
#include <editeng/editstat.hxx>

#include <svx/dialogs.hrc>
#include <sfx2/viewfrm.hxx>
#include <sfx2/sidebar/EnumContext.hxx>
#include <svx/svdopage.hxx>
#include <toolkit/helper/vclunohelper.hxx>
#include <svx/xlndsit.hxx>
#include <svx/xlineit0.hxx>
#include <svx/xlnclit.hxx>
#include <svx/sidebar/ContextChangeEventMultiplexer.hxx>
#include <vcl/virdev.hxx>

#include "app.hrc"
#include "strings.hrc"
#include "Window.hxx"
#include "Client.hxx"
#include "drawdoc.hxx"
#include "DrawDocShell.hxx"
#include "app.hxx"
#include "sdpage.hxx"
#include "glob.hrc"
#include "sdresid.hxx"
#include "DrawViewShell.hxx"
#include "futext.hxx"
#include "fuinsfil.hxx"
#include "slideshow.hxx"
#include "stlpool.hxx"
#include "FrameView.hxx"
#include "ViewClipboard.hxx"
#include "undo/undomanager.hxx"
#include <svx/sdr/contact/viewobjectcontact.hxx>
#include <svx/sdr/contact/viewcontact.hxx>
#include <svx/sdr/contact/displayinfo.hxx>
#include <svx/svdotable.hxx>
#include "EventMultiplexer.hxx"
#include "ViewShellBase.hxx"
#include "ViewShellManager.hxx"

#include <basegfx/polygon/b2dpolygontools.hxx>
#include <basegfx/color/bcolor.hxx>
#include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
#include <drawinglayer/primitive2d/textlayoutdevice.hxx>
#include <drawinglayer/primitive2d/groupprimitive2d.hxx>
#include <svx/sdr/contact/objectcontact.hxx>
#include <svx/sdr/table/tablecontroller.hxx>
#include <basegfx/matrix/b2dhommatrix.hxx>
#include <drawinglayer/primitive2d/textprimitive2d.hxx>
#include <svx/unoapi.hxx>
#include <basegfx/matrix/b2dhommatrixtools.hxx>
#include "DrawController.hxx"

#include <numeric>

using namespace com::sun::star;
using namespace com::sun::star::uno;
using namespace sdr::table;
namespace sd {

#ifndef SO2_DECL_SVINPLACEOBJECT_DEFINED
#define SO2_DECL_SVINPLACEOBJECT_DEFINED
SO2_DECL_REF(SvInPlaceObject)
#endif

TYPEINIT1(View, FmFormView);

/*************************************************************************
|*
|* Ctor
|*
\************************************************************************/

View::View(SdDrawDocument* pDrawDoc, OutputDevice* pOutDev,
			   ViewShell* pViewShell)
  : FmFormView(pDrawDoc, pOutDev),
	mpDoc(pDrawDoc),
	mpDocSh( pDrawDoc->GetDocSh() ),
	mpViewSh(pViewShell),
	mpDragSrcMarkList(NULL),
	mpDropMarkerObj(NULL),
	mpDropMarker(NULL),
	mnDragSrcPgNum(SDRPAGE_NOTFOUND),
	mnAction(DND_ACTION_NONE),
	mnLockRedrawSmph(0),
	mpLockedRedraws(NULL),
	mbIsDropAllowed(sal_True),
	maSmartTags(*this),
    mpClipboard (new ViewClipboard (*this))
{
	// #i73602# Use default from the configuration
	SetBufferedOverlayAllowed(getOptionsDrawinglayer().IsOverlayBuffer_DrawImpress());

	// #i74769#, #i75172# Use default from the configuration
	SetBufferedOutputAllowed(getOptionsDrawinglayer().IsPaintBuffer_DrawImpress());

	EnableExtendedKeyInputDispatcher(sal_False);
	EnableExtendedMouseEventDispatcher(sal_False);
	EnableExtendedCommandEventDispatcher(sal_False);

	SetUseIncompatiblePathCreateInterface(sal_False);
	SetMarkHdlWhenTextEdit(sal_True);
	EnableTextEditOnObjectsWithoutTextIfTextTool(sal_True);

	SetMinMoveDistancePixel(2);
	SetHitTolerancePixel(2);
	SetMeasureLayer(String(SdResId(STR_LAYER_MEASURELINES)));

	// Timer fuer verzoegertes Drop (muss fuer MAC sein)
	maDropErrorTimer.SetTimeoutHdl( LINK(this, View, DropErrorHdl) );
	maDropErrorTimer.SetTimeout(50);
	maDropInsertFileTimer.SetTimeoutHdl( LINK(this, View, DropInsertFileHdl) );
	maDropInsertFileTimer.SetTimeout(50);
}

void View::ImplClearDrawDropMarker()
{
	if(mpDropMarker)
	{
		delete mpDropMarker;
		mpDropMarker = 0L;
	}
}

/*************************************************************************
|*
|* Dtor
|*
\************************************************************************/

View::~View()
{
	maSmartTags.Dispose();

	// release content of selection clipboard, if we own the content
    UpdateSelectionClipboard( sal_True );

	maDropErrorTimer.Stop();
	maDropInsertFileTimer.Stop();

	ImplClearDrawDropMarker();

	while(PaintWindowCount())
	{
		// Alle angemeldeten OutDevs entfernen
		DeleteWindowFromPaintView(GetFirstOutputDevice() /*GetWin(0)*/);
	}

	// gespeicherte Redraws loeschen
	if (mpLockedRedraws)
	{
		SdViewRedrawRec* pRec = (SdViewRedrawRec*)mpLockedRedraws->First();
		while (pRec)
		{
			delete pRec;
			pRec = (SdViewRedrawRec*)mpLockedRedraws->Next();
		}
		delete mpLockedRedraws;
	}
}


class ViewRedirector : public ::sdr::contact::ViewObjectContactRedirector
{
public:
	ViewRedirector();
	virtual ~ViewRedirector();

	// all default implementations just call the same methods at the original. To do something
	// different, overload the method and at least do what the method does.
	virtual drawinglayer::primitive2d::Primitive2DSequence createRedirectedPrimitive2DSequence(
		const sdr::contact::ViewObjectContact& rOriginal,
		const sdr::contact::DisplayInfo& rDisplayInfo);
};

ViewRedirector::ViewRedirector()
{
}

ViewRedirector::~ViewRedirector()
{
}

drawinglayer::primitive2d::Primitive2DSequence ViewRedirector::createRedirectedPrimitive2DSequence(
	const sdr::contact::ViewObjectContact& rOriginal,
	const sdr::contact::DisplayInfo& rDisplayInfo)
{
	SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();
	drawinglayer::primitive2d::Primitive2DSequence xRetval;

	if(pObject && pObject->GetPage())
	{
		const bool bDoCreateGeometry(pObject->GetPage()->checkVisibility( rOriginal, rDisplayInfo, true ));

		if(!bDoCreateGeometry && !(( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_PAGE )) )
			return xRetval;

		PresObjKind eKind(PRESOBJ_NONE);
		const bool bSubContentProcessing(rDisplayInfo.GetSubContentActive());
		const bool bIsMasterPageObject(pObject->GetPage()->IsMasterPage());
		const bool bIsPrinting(rOriginal.GetObjectContact().isOutputToPrinter());
		const SdrPageView* pPageView = rOriginal.GetObjectContact().TryToGetSdrPageView();
        const SdrPage* pVisualizedPage = GetSdrPageFromXDrawPage(rOriginal.GetObjectContact().getViewInformation2D().getVisualizedPage());
		const SdPage* pObjectsSdPage = dynamic_cast< SdPage* >(pObject->GetPage());
		const bool bIsInsidePageObj(pPageView && pPageView->GetPage() != pVisualizedPage);

		// check if we need to draw a placeholder border. Never do it for
		// objects inside a SdrPageObj and never when printing
		if(!bIsInsidePageObj && !bIsPrinting)
		{
			bool bCreateOutline(false);

			if( pObject->IsEmptyPresObj() && pObject->ISA(SdrTextObj) )
			{
				if( !bSubContentProcessing || !pObject->IsNotVisibleAsMaster() )
				{
					eKind = pObjectsSdPage ? pObjectsSdPage->GetPresObjKind(pObject) : PRESOBJ_NONE;
					bCreateOutline = true;
				}
			}
			else if( ( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_TEXT ) )
			{
				if( pObjectsSdPage )
				{
					eKind = pObjectsSdPage->GetPresObjKind(pObject);

					if((eKind == PRESOBJ_FOOTER) || (eKind == PRESOBJ_HEADER) || (eKind == PRESOBJ_DATETIME) || (eKind == PRESOBJ_SLIDENUMBER) )
					{
						if( !bSubContentProcessing )
						{
							// only draw a boundary for header&footer objects on the masterpage itself
							bCreateOutline = true;
						}
					}
				}
			}
			else if( ( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_PAGE ) )
			{
				// only for handout page, else this frame will be created for each
				// page preview object in SlideSorter and PagePane
				if(pObjectsSdPage && PK_HANDOUT == pObjectsSdPage->GetPageKind())
				{
					bCreateOutline = true;
				}
			}

			if(bCreateOutline)
			{
				// empty presentation objects get a gray frame
				const svtools::ColorConfig aColorConfig;
				const svtools::ColorConfigValue aColor( aColorConfig.GetColorValue( svtools::OBJECTBOUNDARIES ) );

				if( aColor.bIsVisible )
				{
					// get basic object transformation
					const basegfx::BColor aRGBColor(Color(aColor.nColor).getBColor());
					basegfx::B2DHomMatrix aObjectMatrix;
					basegfx::B2DPolyPolygon aObjectPolyPolygon;
					pObject->TRGetBaseGeometry(aObjectMatrix, aObjectPolyPolygon);

					// create dashed border
					{
						// create object polygon
						basegfx::B2DPolygon aPolygon(basegfx::tools::createUnitPolygon());
						aPolygon.transform(aObjectMatrix);

						// create line and stroke attribute
						::std::vector< double > aDotDashArray;

						aDotDashArray.push_back(160.0);
						aDotDashArray.push_back(80.0);

						const double fFullDotDashLen(::std::accumulate(aDotDashArray.begin(), aDotDashArray.end(), 0.0));
						const drawinglayer::attribute::LineAttribute aLine(aRGBColor);
						const drawinglayer::attribute::StrokeAttribute aStroke(aDotDashArray, fFullDotDashLen);

						// create primitive and add
						const drawinglayer::primitive2d::Primitive2DReference xRef(new drawinglayer::primitive2d::PolygonStrokePrimitive2D(
							aPolygon,
							aLine,
							aStroke));
						drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval, xRef);
					}

					// now paint the placeholder description, but only when masterpage
					// is displayed as page directly (MasterPage view)
					if(!bSubContentProcessing && bIsMasterPageObject)
					{
						String aObjectString;

						switch( eKind )
						{
							case PRESOBJ_TITLE:
							{
								if(pObjectsSdPage && pObjectsSdPage->GetPageKind() == PK_STANDARD)
								{
									static String aTitleAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_TITLE ) );
									aObjectString = aTitleAreaStr;
								}

								break;
							}
							case PRESOBJ_OUTLINE:
							{
								static String aOutlineAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_OUTLINE ) );
								aObjectString = aOutlineAreaStr;
								break;
							}
							case PRESOBJ_FOOTER:
							{
								static String aFooterAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_FOOTER ) );
								aObjectString = aFooterAreaStr;
								break;
							}
							case PRESOBJ_HEADER:
							{
								static String aHeaderAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_HEADER ) );
								aObjectString = aHeaderAreaStr;
								break;
							}
							case PRESOBJ_DATETIME:
							{
								static String aDateTimeStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_DATETIME ) );
								aObjectString = aDateTimeStr;
								break;
							}
							case PRESOBJ_NOTES:
							{
								static String aDateTimeStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_NOTES ) );
								aObjectString = aDateTimeStr;
								break;
							}
							case PRESOBJ_SLIDENUMBER:
							{
								if(pObjectsSdPage && pObjectsSdPage->GetPageKind() == PK_STANDARD)
								{
									static String aSlideAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_SLIDE ) );
									aObjectString = aSlideAreaStr;
								}
								else
								{
									static String aNumberAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_NUMBER ) );
									aObjectString = aNumberAreaStr;
								}
								break;
							}
							default:
							{
								break;
							}
						}

						if( aObjectString.Len() )
						{
							// decompose object matrix to be able to place text correctly
							basegfx::B2DTuple aScale;
							basegfx::B2DTuple aTranslate;
							double fRotate, fShearX;
							aObjectMatrix.decompose(aScale, aTranslate, fRotate, fShearX);

							// create font
							SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObject );
							const SdrTextVertAdjust eTVA(pTextObj ? pTextObj->GetTextVerticalAdjust() : SDRTEXTVERTADJUST_CENTER);
							Font aScaledVclFont;

							// use a text size factor to get more reliable text sizes from the text layouter
							// (and from vcl), tipp from HDU
							static sal_uInt32 nTextSizeFactor(100);

							// use a factor to get more linear text size calculations
							aScaledVclFont.SetHeight( 500 * nTextSizeFactor );

							// get basic geometry and get text size
							drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;
							aTextLayouter.setFont(aScaledVclFont);
							const xub_StrLen nTextLength(aObjectString.Len());

							// do not forget to use the factor again to get the width for the 500
							const double fTextWidth(aTextLayouter.getTextWidth(aObjectString, 0, nTextLength) * (1.0 / nTextSizeFactor));
							const double fTextHeight(aTextLayouter.getTextHeight() * (1.0 / nTextSizeFactor));

							// calculate text primitive position. If text is at bottom, use top for
							// the extra text and vice versa
							const double fHorDist(125);
							const double fVerDist(125);
							const double fPosX((aTranslate.getX() + aScale.getX()) - fTextWidth - fHorDist);
							const double fPosY((SDRTEXTVERTADJUST_BOTTOM == eTVA)
								? aTranslate.getY() - fVerDist + fTextHeight
								: (aTranslate.getY() + aScale.getY()) - fVerDist);

							// get font attributes; use normally scaled font
							const basegfx::BColor aFontColor(aRGBColor);
							Font aVclFont;
							basegfx::B2DVector aTextSizeAttribute;

							aVclFont.SetHeight( 500 );

							const drawinglayer::attribute::FontAttribute aFontAttribute(
                                drawinglayer::primitive2d::getFontAttributeFromVclFont(
								    aTextSizeAttribute,
								    aVclFont,
								    false,
								    false));

							// fill text matrix
							const basegfx::B2DHomMatrix aTextMatrix(basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
								aTextSizeAttribute.getX(), aTextSizeAttribute.getY(),
								fShearX,
                                fRotate,
                                fPosX, fPosY));

							// create DXTextArray (can be empty one)
							const ::std::vector< double > aDXArray;

							// create locale; this may need some more information in the future
							const ::com::sun::star::lang::Locale aLocale;

							// create primitive and add
							const drawinglayer::primitive2d::Primitive2DReference xRef(
                                new drawinglayer::primitive2d::TextSimplePortionPrimitive2D(
								    aTextMatrix,
								    aObjectString,
								    0,
								    nTextLength,
								    aDXArray,
								    aFontAttribute,
								    aLocale,
								    aFontColor));
							drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval, xRef);
						}
					}
				}
			}
		}

		if(bDoCreateGeometry)
		{
			drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(
				xRetval,
				sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(
					rOriginal,
					rDisplayInfo));
		}
	}
	else
	{
		// not a SdrObject visualisation (maybe e.g. page) or no page
		xRetval = sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
	}

	return xRetval;
}

/*************************************************************************
|*
|* Paint-Methode: das Ereignis wird an die View weitergeleitet
|*
\************************************************************************/

void View::CompleteRedraw(OutputDevice* pOutDev, const Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector /*=0L*/)
{
	// ausfuehren ??
	if (mnLockRedrawSmph == 0)
	{
		SdrPageView* pPgView = GetSdrPageView();

		if (pPgView)
		{
			SdPage* pPage = (SdPage*) pPgView->GetPage();
			if( pPage )
			{
				SdrOutliner& rOutl=mpDoc->GetDrawOutliner(NULL);
                bool bScreenDisplay(true);

                if(bScreenDisplay && pOutDev && OUTDEV_PRINTER == pOutDev->GetOutDevType())
                {
                    // #i75566# printing; suppress AutoColor BackgroundColor generation
                    // for visibility reasons by giving GetPageBackgroundColor()
                    // the needed hint
                    bScreenDisplay = false;
                }

                if(bScreenDisplay && pOutDev && pOutDev->GetPDFWriter())
                {
                    // #i75566# PDF export; suppress AutoColor BackgroundColor generation (see above)
                    bScreenDisplay = false;
                }

                // #i75566# Name change GetBackgroundColor -> GetPageBackgroundColor and
                // hint value if screen display. Only then the AutoColor mechanisms shall be applied
				rOutl.SetBackgroundColor( pPage->GetPageBackgroundColor(pPgView, bScreenDisplay) );
			}
		}

		ViewRedirector aViewRedirector;
		FmFormView::CompleteRedraw(pOutDev, rReg, pRedirector ? pRedirector : &aViewRedirector);
	}
	// oder speichern?
	else
	{
		if (!mpLockedRedraws)
			mpLockedRedraws = new List;

		SdViewRedrawRec* pRec = new SdViewRedrawRec;
		pRec->mpOut	= pOutDev;
		pRec->aRect = rReg.GetBoundRect();
		mpLockedRedraws->Insert(pRec, LIST_APPEND);
	}
}


/*************************************************************************
|*
|* Selektion hat sich geaendert
|*
\************************************************************************/

void View::MarkListHasChanged()
{
	FmFormView::MarkListHasChanged();

	if( GetMarkedObjectCount() > 0 )
		maSmartTags.deselect();
}


/*************************************************************************
|*
|* Attribute setzen
|*
\************************************************************************/

sal_Bool View::SetAttributes(const SfxItemSet& rSet, sal_Bool bReplaceAll)
{
	sal_Bool bOk = FmFormView::SetAttributes(rSet, bReplaceAll);
	return (bOk);
}


/*************************************************************************
|*
|* Attribute holen
|*
\************************************************************************/

sal_Bool View::GetAttributes( SfxItemSet& rTargetSet, sal_Bool bOnlyHardAttr ) const
{
	return( FmFormView::GetAttributes( rTargetSet, bOnlyHardAttr ) );
}


/*************************************************************************
|*
|* Ist ein Praesentationsobjekt selektiert?
|*
\************************************************************************/

sal_Bool View::IsPresObjSelected(sal_Bool bOnPage, sal_Bool bOnMasterPage, sal_Bool bCheckPresObjListOnly, sal_Bool bCheckLayoutOnly) const
{
	/**************************************************************************
	* Ist ein Presentationsobjekt selektiert?
	**************************************************************************/
	SdrMarkList* pMarkList;

	if (mnDragSrcPgNum != SDRPAGE_NOTFOUND &&
		mnDragSrcPgNum != GetSdrPageView()->GetPage()->GetPageNum())
	{
		// Es laeuft gerade Drag&Drop
		// Source- und Destination-Page unterschiedlich:
		// es wird die gemerkte MarkList verwendet
		pMarkList = mpDragSrcMarkList;
	}
	else
	{
		// Es wird die aktuelle MarkList verwendet
		pMarkList = new SdrMarkList(GetMarkedObjectList());
	}

	SdrMark* pMark;
	SdPage* pPage;
	SdrObject* pObj;

	sal_Bool bSelected = sal_False;
	sal_Bool bMasterPage = sal_False;
	long nMark;
	long nMarkMax = long(pMarkList->GetMarkCount()) - 1;

	for (nMark = nMarkMax; (nMark >= 0) && !bSelected; nMark--)
	{
		// Rueckwaerts durch die Marklist
		pMark = pMarkList->GetMark(nMark);
		pObj = pMark->GetMarkedSdrObj();

		if ( pObj && ( bCheckPresObjListOnly || pObj->IsEmptyPresObj() || pObj->GetUserCall() ) )
		{
			pPage = (SdPage*) pObj->GetPage();
			bMasterPage = pPage->IsMasterPage();

			if ( (bMasterPage && bOnMasterPage) || (!bMasterPage && bOnPage) )
			{
				if ( pPage && pPage->IsPresObj(pObj) )
				{
					if( bCheckLayoutOnly )
					{
						PresObjKind eKind = pPage->GetPresObjKind(pObj);

						if((eKind != PRESOBJ_FOOTER) && (eKind != PRESOBJ_HEADER) && (eKind != PRESOBJ_DATETIME) && (eKind != PRESOBJ_SLIDENUMBER) )
							bSelected = sal_True;
					}
					else
					{
						bSelected = sal_True;
					}
				}
			}
		}
	}

	if (pMarkList != mpDragSrcMarkList)
	{
	   delete pMarkList;
	}

	return (bSelected);
}

/*************************************************************************
|*
|* Alles selektieren
|*
\************************************************************************/

void View::SelectAll()
{
	if ( IsTextEdit() )
	{
		OutlinerView* pOLV = GetTextEditOutlinerView();
		const ::Outliner* pOutliner = GetTextEditOutliner();
		pOLV->SelectRange( 0, (sal_uInt16) pOutliner->GetParagraphCount() );
	}
	else
	{
		MarkAll();
	}
}


/*************************************************************************
|*
|* Dokument hat sich geaendert
|*
\************************************************************************/

void View::ModelHasChanged()
{
	// Erst SdrView benachrichtigen
	FmFormView::ModelHasChanged();
}

/*************************************************************************
|*
|* StyleSheet setzen
|*
\************************************************************************/

sal_Bool View::SetStyleSheet(SfxStyleSheet* pStyleSheet, sal_Bool bDontRemoveHardAttr)
{
	// weiter an SdrView
	return FmFormView::SetStyleSheet(pStyleSheet, bDontRemoveHardAttr);
}


/*************************************************************************
|*
|* Texteingabe beginnen
|*
\************************************************************************/

static void SetSpellOptions( SdDrawDocument* pDoc, sal_uLong& rCntrl )
{
	sal_Bool bOnlineSpell = pDoc->GetOnlineSpell();

	if( bOnlineSpell )
		rCntrl |= EE_CNTRL_ONLINESPELLING;
	else
		rCntrl &= ~EE_CNTRL_ONLINESPELLING;
}

sal_Bool View::SdrBeginTextEdit(
	SdrObject* pObj, SdrPageView* pPV, ::Window* pWin,
	sal_Bool bIsNewObj,
	SdrOutliner* pOutl, OutlinerView* pGivenOutlinerView,
    sal_Bool bDontDeleteOutliner, sal_Bool bOnlyOneView, sal_Bool bGrabFocus )
{
	GetViewShell()->GetViewShellBase().GetEventMultiplexer()->MultiplexEvent(
        sd::tools::EventMultiplexerEvent::EID_BEGIN_TEXT_EDIT, (void*)pObj );

	if( pOutl==NULL && pObj )
		pOutl = SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, pObj->GetModel() );

	// make draw&impress specific initialisations
	if( pOutl )
	{
		pOutl->SetStyleSheetPool((SfxStyleSheetPool*) mpDoc->GetStyleSheetPool());
		pOutl->SetCalcFieldValueHdl(LINK(SD_MOD(), SdModule, CalcFieldValueHdl));
		sal_uLong nCntrl = pOutl->GetControlWord();
		nCntrl |= EE_CNTRL_ALLOWBIGOBJS;
		nCntrl |= EE_CNTRL_URLSFXEXECUTE;
		nCntrl |= EE_CNTRL_MARKFIELDS;
		nCntrl |= EE_CNTRL_AUTOCORRECT;

		nCntrl &= ~EE_CNTRL_ULSPACESUMMATION;
		if ( mpDoc->IsSummationOfParagraphs() )
		    nCntrl |= EE_CNTRL_ULSPACESUMMATION;

		SetSpellOptions( mpDoc, nCntrl );

		pOutl->SetControlWord(nCntrl);

		Reference< linguistic2::XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() );
        if ( xSpellChecker.is() )
            pOutl->SetSpeller( xSpellChecker );

		Reference< linguistic2::XHyphenator > xHyphenator( LinguMgr::GetHyphenator() );
        if( xHyphenator.is() )
            pOutl->SetHyphenator( xHyphenator );

		pOutl->SetDefaultLanguage( Application::GetSettings().GetLanguage() );
	}

	sal_Bool bReturn = FmFormView::SdrBeginTextEdit(
		pObj, pPV, pWin, bIsNewObj, pOutl,
		pGivenOutlinerView, bDontDeleteOutliner,
		bOnlyOneView, bGrabFocus);

    if ( mpViewSh )
    {
        mpViewSh->GetViewShellBase().GetDrawController().FireSelectionChangeListener();
    }

    if (bReturn)
    {
        ::Outliner* pOL = GetTextEditOutliner();

        if( pObj && pObj->GetPage() )
        {
            Color aBackground;
            if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_TABLE )
            {
                aBackground = GetTextEditBackgroundColor(*this);
            }
            else
            {
                aBackground = pObj->GetPage()->GetPageBackgroundColor(pPV);
            }
            if (pOL != NULL)
                pOL->SetBackgroundColor( aBackground  );
        }

        if (pOL != NULL)
        {
            pOL->SetParaInsertedHdl(LINK(this, View, OnParagraphInsertedHdl));
            pOL->SetParaRemovingHdl(LINK(this, View, OnParagraphRemovingHdl));
        }
    }

    return(bReturn);
}

/** ends current text editing */
SdrEndTextEditKind View::SdrEndTextEdit(sal_Bool bDontDeleteReally )
{
	SdrObjectWeakRef xObj( GetTextEditObject() );

	sal_Bool bDefaultTextRestored = RestoreDefaultText( dynamic_cast< SdrTextObj* >( GetTextEditObject() ) );

	SdrEndTextEditKind eKind = FmFormView::SdrEndTextEdit(bDontDeleteReally);

	if( bDefaultTextRestored )
	{
		if( xObj.is() && !xObj->IsEmptyPresObj() )
		{
			xObj->SetEmptyPresObj( sal_True );
		}
		else
		{
			eKind = SDRENDTEXTEDIT_UNCHANGED;
		}
	}
	else if( xObj.is() && xObj->IsEmptyPresObj() )
	{
		SdrTextObj* pObj = dynamic_cast< SdrTextObj* >( xObj.get() );
		if( pObj && pObj->HasText() )
		{
			SdrPage* pPage = pObj->GetPage();
			if( !pPage || !pPage->IsMasterPage() )
				pObj->SetEmptyPresObj( sal_False );
		}
	}

    GetViewShell()->GetViewShellBase().GetEventMultiplexer()->MultiplexEvent(
        sd::tools::EventMultiplexerEvent::EID_END_TEXT_EDIT,
        (void*)xObj.get() );

    if( xObj.is() )
    {
        if ( mpViewSh )
        {
            mpViewSh->GetViewShellBase().GetDrawController().FireSelectionChangeListener();
        }

        SdPage* pPage = dynamic_cast< SdPage* >( xObj->GetPage() );
        if( pPage )
            pPage->onEndTextEdit( xObj.get() );
    }

    return(eKind);
}

// --------------------------------------------------------------------

/** restores the default text if the given text object is currently in edit mode and
	no text has been entered already. Is only usefull just before text edit ends. */
bool View::RestoreDefaultText( SdrTextObj* pTextObj )
{
	bool bRestored = false;

	if( pTextObj && (pTextObj == GetTextEditObject()) )
	{
		if( !pTextObj->HasText() )
		{
			SdPage* pPage = dynamic_cast< SdPage* >( pTextObj->GetPage() );

			if(pPage)
			{
				bRestored = pPage->RestoreDefaultText( pTextObj );
				if( bRestored )
				{
					SdrOutliner* pOutliner = GetTextEditOutliner();
					pTextObj->SetTextEditOutliner( pOutliner );
					OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
					if (pOutliner)
						pOutliner->SetText(*pParaObj);
				}
			}
		}
	}

	return bRestored;
}

/*************************************************************************
|*
|* Originalgroesse der markierten Objekte setzen
|*
\************************************************************************/

void View::SetMarkedOriginalSize()
{
	SdrUndoGroup*   pUndoGroup = new SdrUndoGroup(*mpDoc);
	sal_uLong           nCount = GetMarkedObjectCount();
	sal_Bool            bOK = sal_False;

	for( sal_uInt32 i = 0; i < nCount; i++ )
	{
		SdrObject* pObj = GetMarkedObjectByIndex(i);

		if( pObj->GetObjInventor() == SdrInventor )
		{
			if( pObj->GetObjIdentifier() == OBJ_OLE2 )
			{
                uno::Reference < embed::XEmbeddedObject > xObj = ((SdrOle2Obj*)pObj)->GetObjRef();
                if( xObj.is() )
				{
                    // TODO/LEAN: working with VisualArea can switch object to running state

                   	sal_Int64 nAspect = ((SdrOle2Obj*)pObj)->GetAspect();
					Size aOleSize;

					if ( nAspect == embed::Aspects::MSOLE_ICON )
					{
						MapMode aMap100( MAP_100TH_MM );
                    	aOleSize = ((SdrOle2Obj*)pObj)->GetOrigObjSize( &aMap100 );
                    	bOK = sal_True;
					}
					else
					{
                    	MapUnit aUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( nAspect ) );
						try
						{
                    		awt::Size aSz = xObj->getVisualAreaSize( nAspect );
                    		aOleSize = OutputDevice::LogicToLogic( Size( aSz.Width, aSz.Height ), aUnit, MAP_100TH_MM );
                    		bOK = sal_True;
						}
						catch( embed::NoVisualAreaSizeException& )
						{}
					}

					if ( bOK )
					{
						Rectangle   aDrawRect( pObj->GetLogicRect() );

						pUndoGroup->AddAction( mpDoc->GetSdrUndoFactory().CreateUndoGeoObject( *pObj ) );
						pObj->Resize( aDrawRect.TopLeft(), Fraction( aOleSize.Width(), aDrawRect.GetWidth() ),
													   	Fraction( aOleSize.Height(), aDrawRect.GetHeight() ) );
					}
                }
			}
			else if( pObj->GetObjIdentifier() == OBJ_GRAF )
			{
				const MapMode   aMap100( MAP_100TH_MM );
				Size            aSize;

			    if ( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefMapMode().GetMapUnit() == MAP_PIXEL )
				    aSize = Application::GetDefaultDevice()->PixelToLogic( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefSize(), aMap100 );
			    else
			    {
				    aSize = OutputDevice::LogicToLogic( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefSize(),
														static_cast< SdrGrafObj* >( pObj )->GetGrafPrefMapMode(),
														aMap100 );
				}

				pUndoGroup->AddAction( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj ) );
				Rectangle aRect( pObj->GetLogicRect() );
				aRect.SetSize( aSize );
				pObj->SetLogicRect( aRect );

				bOK = sal_True;
			}
		}
	}

	if( bOK )
	{
		pUndoGroup->SetComment( String(SdResId(STR_UNDO_ORIGINALSIZE)) );
		mpDocSh->GetUndoManager()->AddUndoAction(pUndoGroup);
	}
	else
		delete pUndoGroup;
}

/*************************************************************************
|*
|* OLE-Obj am Client connecten
|*
\************************************************************************/

void View::DoConnect(SdrOle2Obj* pObj)
{
	if (mpViewSh)
	{
        uno::Reference < embed::XEmbeddedObject > xObj( pObj->GetObjRef() );
        if( xObj.is() )
		{
            ::sd::Window* pWindow = mpViewSh->GetActiveWindow();
            SfxInPlaceClient* pSdClient = mpViewSh-> GetViewShellBase().FindIPClient( xObj, pWindow );
            if ( !pSdClient )
			{
                pSdClient = new Client(pObj, mpViewSh, pWindow);
				Rectangle aRect = pObj->GetLogicRect();
				{
                    // TODO/LEAN: working with visual area can switch object to running state
					Size aDrawSize = aRect.GetSize();
                    awt::Size aSz;

					MapMode aMapMode( mpDoc->GetScaleUnit() );
                    Size aObjAreaSize = pObj->GetOrigObjSize( &aMapMode );

					Fraction aScaleWidth (aDrawSize.Width(),  aObjAreaSize.Width() );
					Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() );
					aScaleWidth.ReduceInaccurate(10);		// kompatibel zum SdrOle2Obj
					aScaleHeight.ReduceInaccurate(10);
                    pSdClient->SetSizeScale(aScaleWidth, aScaleHeight);

					// sichtbarer Ausschnitt wird nur inplace veraendert!
					// the object area must be set after the scaling, since it triggers resize
					aRect.SetSize(aObjAreaSize);
                    pSdClient->SetObjArea(aRect);
				}
			}
        }
	}
}

/*************************************************************************
|*
|*
|*
\************************************************************************/

sal_Bool View::IsMorphingAllowed() const
{
	const SdrMarkList&	rMarkList = GetMarkedObjectList();
	sal_Bool				bRet = sal_False;

	if ( rMarkList.GetMarkCount() == 2 )
	{
		const SdrObject*	pObj1 = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
		const SdrObject*	pObj2 = rMarkList.GetMark( 1 )->GetMarkedSdrObj();
		const sal_uInt16		nKind1 = pObj1->GetObjIdentifier();
		const sal_uInt16		nKind2 = pObj2->GetObjIdentifier();

		if ( ( nKind1 != OBJ_TEXT && nKind2 != OBJ_TEXT ) &&
			 ( nKind1 != OBJ_TITLETEXT && nKind2 != OBJ_TITLETEXT ) &&
			 ( nKind1 != OBJ_OUTLINETEXT && nKind2 != OBJ_OUTLINETEXT ) &&
			 ( nKind1 != OBJ_GRUP && nKind2 != OBJ_GRUP ) &&
			 ( nKind1 != OBJ_LINE && nKind2 != OBJ_LINE ) &&
			 ( nKind1 != OBJ_PLIN && nKind2 != OBJ_PLIN ) &&
			 ( nKind1 != OBJ_PATHLINE && nKind2 != OBJ_PATHLINE ) &&
			 ( nKind1 != OBJ_FREELINE && nKind2 != OBJ_FREELINE ) &&
			 ( nKind1 != OBJ_PATHPLIN && nKind2 != OBJ_PATHPLIN ) &&
			 ( nKind1 != OBJ_MEASURE && nKind2 != OBJ_MEASURE ) &&
			 ( nKind1 != OBJ_EDGE && nKind2 != OBJ_EDGE ) &&
			 ( nKind1 != OBJ_GRAF && nKind2 != OBJ_GRAF ) &&
			 ( nKind1 != OBJ_OLE2 && nKind2 != OBJ_OLE2 ) &&
			 ( nKind1 != OBJ_CAPTION && nKind2 !=  OBJ_CAPTION ) &&
			 !pObj1->ISA( E3dObject) && !pObj2->ISA( E3dObject) )
		{
			SfxItemSet		aSet1( mpDoc->GetPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE );
			SfxItemSet		aSet2( mpDoc->GetPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE );

			aSet1.Put(pObj1->GetMergedItemSet());
			aSet2.Put(pObj2->GetMergedItemSet());

			const XFillStyle	eFillStyle1 = ( (const XFillStyleItem&) aSet1.Get( XATTR_FILLSTYLE ) ).GetValue();
			const XFillStyle	eFillStyle2 = ( (const XFillStyleItem&) aSet2.Get( XATTR_FILLSTYLE ) ).GetValue();

			if( ( eFillStyle1 == XFILL_NONE || eFillStyle1 == XFILL_SOLID ) &&
				( eFillStyle2 == XFILL_NONE || eFillStyle2 == XFILL_SOLID ) )
				bRet = sal_True;
		}
	}

	return bRet;
}

/*************************************************************************
|*
|*
|*
\************************************************************************/

sal_Bool View::IsVectorizeAllowed() const
{
	const SdrMarkList&	rMarkList = GetMarkedObjectList();
	sal_Bool				bRet = sal_False;

	if( rMarkList.GetMarkCount() == 1 )
	{
		const SdrGrafObj* pObj = dynamic_cast< const SdrGrafObj* >(rMarkList.GetMark( 0 )->GetMarkedSdrObj());

        if(pObj)
        {
            if(GRAPHIC_BITMAP == pObj->GetGraphicType() && !pObj->isEmbeddedSvg())
            {
                bRet = sal_True;
            }
        }
	}

	return bRet;
}

void View::onAccessibilityOptionsChanged()
{
	if( mpViewSh )
	{
		::sd::Window* pWindow = mpViewSh->GetActiveWindow();
		if( pWindow )
		{
			const StyleSettings& rStyleSettings = pWindow->GetSettings().GetStyleSettings();

			sal_uInt16 nOutputSlot, nPreviewSlot;

			SvtAccessibilityOptions& aAccOptions = getAccessibilityOptions();

			if( mpViewSh->GetViewFrame() && mpViewSh->GetViewFrame()->GetDispatcher() )
			{
				if( rStyleSettings.GetHighContrastMode() )
				{
					nOutputSlot = SID_OUTPUT_QUALITY_CONTRAST;
				}
				else
				{
					nOutputSlot = SID_OUTPUT_QUALITY_COLOR;
				}

				if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForPagePreviews() )
				{
					nPreviewSlot = SID_PREVIEW_QUALITY_CONTRAST;
				}
				else
				{
					nPreviewSlot = SID_PREVIEW_QUALITY_COLOR;
				}

				mpViewSh->GetViewFrame()->GetDispatcher()->Execute( nOutputSlot, SFX_CALLMODE_ASYNCHRON );
				mpViewSh->GetViewFrame()->GetDispatcher()->Execute( nPreviewSlot, SFX_CALLMODE_ASYNCHRON );
			}

			mpViewSh->Invalidate();
		}
	}
}

IMPL_LINK( View, OnParagraphInsertedHdl, ::Outliner *, pOutliner )
{
	Paragraph* pPara = pOutliner->GetHdlParagraph();
	SdrObject* pObj = GetTextEditObject();

	if( pPara && pObj )
	{
		SdPage* pPage = dynamic_cast< SdPage* >( pObj->GetPage() );
		if( pPage )
			pPage->onParagraphInserted( pOutliner, pPara, pObj );
	}
	return 0;
}

/*************************************************************************
|*
|* Handler fuer das Loeschen von Seiten (Absaetzen)
|*
\************************************************************************/

IMPL_LINK( View, OnParagraphRemovingHdl, ::Outliner *, pOutliner )
{
	Paragraph* pPara = pOutliner->GetHdlParagraph();
	SdrObject* pObj = GetTextEditObject();

	if( pPara && pObj )
	{
		SdPage* pPage = dynamic_cast< SdPage* >( pObj->GetPage() );
		if( pPage )
			pPage->onParagraphRemoving( pOutliner, pPara, pObj );
	}
	return 0;
}

bool View::isRecordingUndo() const
{
	if( mpDoc && mpDoc->IsUndoEnabled() )
	{
		sd::UndoManager* pUndoManager = mpDoc ? mpDoc->GetUndoManager() : 0;
		return pUndoManager && pUndoManager->IsInListAction();
	}
	else
	{
		return false;
	}
}

void View::AddCustomHdl()
{
	maSmartTags.addCustomHandles( aHdl );
}

void View::updateHandles()
{
	AdjustMarkHdl();
}

SdrViewContext View::GetContext() const
{
	SdrViewContext eContext = SDRCONTEXT_STANDARD;
	if( maSmartTags.getContext( eContext ) )
		return eContext;
	else
		return FmFormView::GetContext();
}

sal_Bool View::HasMarkablePoints() const
{
	if( maSmartTags.HasMarkablePoints() )
		return true;
	else
		return FmFormView::HasMarkablePoints();
}

sal_uLong View::GetMarkablePointCount() const
{
	sal_uLong nCount = FmFormView::GetMarkablePointCount();
	nCount += maSmartTags.GetMarkablePointCount();
	return nCount;
}

sal_Bool View::HasMarkedPoints() const
{
	if( maSmartTags.HasMarkedPoints() )
		return true;
	else
		return FmFormView::HasMarkedPoints();
}

sal_uLong View::GetMarkedPointCount() const
{
	sal_uLong nCount = FmFormView::GetMarkedPointCount();
	nCount += maSmartTags.GetMarkedPointCount();
	return nCount;
}

sal_Bool View::IsPointMarkable(const SdrHdl& rHdl) const
{
	if( maSmartTags.IsPointMarkable( rHdl ) )
		return true;
	else
		return FmFormView::IsPointMarkable( rHdl );
}

sal_Bool View::MarkPoint(SdrHdl& rHdl, sal_Bool bUnmark )
{
	if( maSmartTags.MarkPoint( rHdl, bUnmark ) )
		return true;
	else
		return FmFormView::MarkPoint( rHdl, bUnmark );
}

sal_Bool View::MarkPoints(const Rectangle* pRect, sal_Bool bUnmark)
{
	if( maSmartTags.MarkPoints( pRect, bUnmark ) )
		return true;
	else
		return FmFormView::MarkPoints( pRect, bUnmark );
}

void View::CheckPossibilities()
{
	FmFormView::CheckPossibilities();
	maSmartTags.CheckPossibilities();
}

void View::OnBeginPasteOrDrop( PasteOrDropInfos* /*pInfos*/ )
{
}

/** this is called after a paste or drop operation, make sure that the newly inserted paragraphs
	get the correct style sheet. */
void View::OnEndPasteOrDrop( PasteOrDropInfos* pInfos )
{
	SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( GetTextEditObject() );
	SdrOutliner* pOutliner = GetTextEditOutliner();
	if( pOutliner && pTextObj && pTextObj->GetPage() )
	{
		SdPage* pPage = static_cast< SdPage* >( pTextObj->GetPage() );

		SfxStyleSheet* pStyleSheet = 0;

		const PresObjKind eKind = pPage->GetPresObjKind(pTextObj);
		if( eKind != PRESOBJ_NONE )
			pStyleSheet = pPage->GetStyleSheetForPresObj(eKind);
		else
			pStyleSheet = pTextObj->GetStyleSheet();

		if( eKind == PRESOBJ_OUTLINE )
		{
			// for outline shapes, set the correct outline style sheet for each
			// new paragraph, depending on the paragraph depth
			SfxStyleSheetBasePool* pStylePool = GetDoc()->GetStyleSheetPool();

			for ( sal_uInt16 nPara = pInfos->nStartPara; nPara <= pInfos->nEndPara; nPara++ )
			{
				sal_Int16 nDepth = pOutliner->GetDepth( nPara );

				SfxStyleSheet* pStyle = 0;
				if( nDepth > 0 )
				{
					String aStyleSheetName( pStyleSheet->GetName() );
					aStyleSheetName.Erase( aStyleSheetName.Len() - 1, 1 );
					aStyleSheetName += String::CreateFromInt32( nDepth );
					pStyle = static_cast<SfxStyleSheet*>( pStylePool->Find( aStyleSheetName, pStyleSheet->GetFamily() ) );
					DBG_ASSERT( pStyle, "sd::View::OnEndPasteOrDrop(), Style not found!" );
				}

				if( !pStyle )
					pStyle = pStyleSheet;

				pOutliner->SetStyleSheet( nPara, pStyle );
			}
		}
		else
		{
			// just put the object style on each new paragraph
			for ( sal_uInt16 nPara = pInfos->nStartPara; nPara <= pInfos->nEndPara; nPara++ )
			{
				pOutliner->SetStyleSheet( nPara, pStyleSheet );
			}
		}
	}
}

sal_Bool View::ShouldToggleOn(sal_Bool bBulletOnOffMode, sal_Bool bNormalBullet)
{
	// If setting bullets/numbering by the dialog, always should toggle on.
	if (!bBulletOnOffMode)
		return sal_True;
	SdrModel* pSdrModel = GetModel();
	if (!pSdrModel)
		return sal_False;

	sal_Bool bToggleOn = sal_False;
	SdrOutliner* pOutliner = SdrMakeOutliner(OUTLINERMODE_TEXTOBJECT, pSdrModel);
	sal_uInt32 nMarkCount = GetMarkedObjectCount();
	for (sal_uInt32 nIndex = 0; nIndex < nMarkCount && !bToggleOn; nIndex++)
	{
		SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >(GetMarkedObjectByIndex(nIndex));
		if (!pTextObj || pTextObj->IsTextEditActive())
			continue;
		if (pTextObj->ISA(SdrTableObj))
		{
			SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >(pTextObj);
			if (!pTableObj)
				continue;
			CellPos aStart, aEnd;
			SvxTableController* pTableController = dynamic_cast< SvxTableController* >(getSelectionController().get());
			if (pTableController)
			{
				pTableController->getSelectedCells(aStart, aEnd);
			}
			else
			{
				aStart = pTableObj->getFirstCell();
				aEnd = pTableObj->getLastCell();
			}
			sal_Int32 nColCount = pTableObj->getColumnCount();
			for (sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow && !bToggleOn; nRow++)
			{
				for (sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol && !bToggleOn; nCol++)
				{
					sal_Int32 nIndex = nRow * nColCount + nCol;
					SdrText* pText = pTableObj->getText(nIndex);
					if (!pText || !pText->GetOutlinerParaObject())
						continue;
					pOutliner->SetText(*(pText->GetOutlinerParaObject()));
					sal_Int16 nStatus = pOutliner->GetBulletsNumberingStatus();
					bToggleOn = ((bNormalBullet && nStatus != 0) || (!bNormalBullet && nStatus != 1)) ? sal_True : bToggleOn;
					pOutliner->Clear();
				}
			}
		}
		else
		{
			OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
			if (!pParaObj)
				continue;
			pOutliner->SetText(*pParaObj);
			sal_Int16 nStatus = pOutliner->GetBulletsNumberingStatus();
			bToggleOn = ((bNormalBullet && nStatus != 0) || (!bNormalBullet && nStatus != 1)) ? sal_True : bToggleOn;
			pOutliner->Clear();
		}
	}
	delete pOutliner;
	return bToggleOn;
}

void View::ToggleMarkedObjectsBullets(sal_Bool bBulletOnOffMode, sal_Bool bNormalBullet, sal_Bool bMasterView, SvxNumRule* pNumRule, sal_Bool bForceBulletOnOff)
{
	SdrModel* pSdrModel = GetModel();
	Window* pWindow = dynamic_cast< Window* >(GetFirstOutputDevice());
	if (!pSdrModel || !pWindow)
		return;

	sal_Bool bUndoEnabled = pSdrModel->IsUndoEnabled();
	sal_Bool bToggleOn = ShouldToggleOn(bBulletOnOffMode, bNormalBullet);
	if ( bForceBulletOnOff ) {
		bToggleOn = bBulletOnOffMode;
	}
	SdrUndoGroup* pUndoGroup = new SdrUndoGroup(*pSdrModel);
	SdrOutliner* pOutliner = SdrMakeOutliner(OUTLINERMODE_TEXTOBJECT, pSdrModel);
	OutlinerView* pOutlinerView = new OutlinerView(pOutliner, pWindow);

	sal_uInt32 nMarkCount = GetMarkedObjectCount();
	for (sal_uInt32 nIndex = 0; nIndex < nMarkCount; nIndex++)
	{
		SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >(GetMarkedObjectByIndex(nIndex));
		if (!pTextObj || pTextObj->IsTextEditActive())
			continue;
		if (pTextObj->ISA(SdrTableObj))
		{
			SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >(pTextObj);
			if (!pTableObj)
				continue;
			CellPos aStart, aEnd;
			SvxTableController* pTableController = dynamic_cast< SvxTableController* >(getSelectionController().get());
			if (pTableController)
			{
				pTableController->getSelectedCells(aStart, aEnd);
			}
			else
			{
				aStart = pTableObj->getFirstCell();
				aEnd = pTableObj->getLastCell();
			}
			sal_Int32 nColCount = pTableObj->getColumnCount();
			for (sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++)
			{
				for (sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++)
				{
					sal_Int32 nIndex = nRow * nColCount + nCol;
					SdrText* pText = pTableObj->getText(nIndex);
					if (!pText || !pText->GetOutlinerParaObject())
						continue;

					pOutliner->SetText(*(pText->GetOutlinerParaObject()));
					if (bUndoEnabled)
					{
						SdrUndoObjSetText* pTxtUndo = dynamic_cast< SdrUndoObjSetText* >(pSdrModel->GetSdrUndoFactory().CreateUndoObjectSetText(*pTextObj, nIndex));
						pUndoGroup->AddAction(pTxtUndo);
					}
					pOutlinerView->ToggleAllParagraphsBullets(bBulletOnOffMode, bNormalBullet, bToggleOn, bMasterView, pNumRule);
					sal_uInt32 nParaCount = pOutliner->GetParagraphCount();
					pText->SetOutlinerParaObject(pOutliner->CreateParaObject(0, (sal_uInt16)nParaCount));
					pOutliner->Clear();
				}
			}
			// Broadcast the object change event.
			if (!pTextObj->AdjustTextFrameWidthAndHeight())
			{
				pTextObj->SetChanged();
				pTextObj->BroadcastObjectChange();
			}
		}
		else
		{
			OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
			if (!pParaObj)
				continue;
			pOutliner->SetText(*pParaObj);
			if (bUndoEnabled)
			{
				SdrUndoObjSetText* pTxtUndo = dynamic_cast< SdrUndoObjSetText* >(pSdrModel->GetSdrUndoFactory().CreateUndoObjectSetText(*pTextObj, 0));
				pUndoGroup->AddAction(pTxtUndo);
			}
			pOutlinerView->ToggleAllParagraphsBullets(bBulletOnOffMode, bNormalBullet, bToggleOn, bMasterView, pNumRule);
			sal_uInt32 nParaCount = pOutliner->GetParagraphCount();
			pTextObj->SetOutlinerParaObject(pOutliner->CreateParaObject(0, (sal_uInt16)nParaCount));
			pOutliner->Clear();
		}
	}

	if (pUndoGroup->GetActionCount() > 0 && bUndoEnabled)
	{
		pSdrModel->BegUndo();
		pSdrModel->AddUndo(pUndoGroup);
		pSdrModel->EndUndo();
	}
	else
	{
		delete pUndoGroup;
	}
	delete pOutliner;
	delete pOutlinerView;
}

} // end of namespace sd