xref: /aoo42x/main/sd/source/ui/view/sdview.cxx (revision 7a980842)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sd.hxx"
26 #include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
27 #include <com/sun/star/linguistic2/XSpellChecker1.hpp>
28 
29 #include "View.hxx"
30 #include <editeng/unolingu.hxx>
31 #include <sfx2/request.hxx>
32 #include <svx/obj3d.hxx>
33 #include <svx/fmview.hxx>
34 #include <editeng/outliner.hxx>
35 #ifndef _SVX_SVXIDS_HRC
36 #include <svx/svxids.hrc>
37 #endif
38 #include <svx/svdograf.hxx>
39 #include <svx/svdoole2.hxx>
40 #include <svx/svdundo.hxx>
41 #include <vcl/msgbox.hxx>
42 #include <sfx2/dispatch.hxx>
43 #include <sfx2/app.hxx>
44 #include <svx/svdpagv.hxx>
45 #include <sfx2/docfile.hxx>
46 #include <svx/svdoutl.hxx>
47 #include <svx/sdr/contact/displayinfo.hxx>
48 
49 #include <svx/svdetc.hxx>
50 #include <editeng/editstat.hxx>
51 
52 #include <svx/dialogs.hrc>
53 #include <sfx2/viewfrm.hxx>
54 #include <sfx2/sidebar/EnumContext.hxx>
55 #include <svx/svdopage.hxx>
56 #include <toolkit/helper/vclunohelper.hxx>
57 #include <svx/xlndsit.hxx>
58 #include <svx/xlineit0.hxx>
59 #include <svx/xlnclit.hxx>
60 #include <svx/sidebar/ContextChangeEventMultiplexer.hxx>
61 #include <vcl/virdev.hxx>
62 
63 #include "app.hrc"
64 #include "strings.hrc"
65 #include "Window.hxx"
66 #include "Client.hxx"
67 #include "drawdoc.hxx"
68 #include "DrawDocShell.hxx"
69 #include "app.hxx"
70 #include "sdpage.hxx"
71 #include "glob.hrc"
72 #include "sdresid.hxx"
73 #include "DrawViewShell.hxx"
74 #include "futext.hxx"
75 #include "fuinsfil.hxx"
76 #include "slideshow.hxx"
77 #include "stlpool.hxx"
78 #include "FrameView.hxx"
79 #include "ViewClipboard.hxx"
80 #include "undo/undomanager.hxx"
81 #include <svx/sdr/contact/viewobjectcontact.hxx>
82 #include <svx/sdr/contact/viewcontact.hxx>
83 #include <svx/sdr/contact/displayinfo.hxx>
84 #include <svx/svdotable.hxx>
85 #include "EventMultiplexer.hxx"
86 #include "ViewShellBase.hxx"
87 #include "ViewShellManager.hxx"
88 
89 #include <basegfx/polygon/b2dpolygontools.hxx>
90 #include <basegfx/color/bcolor.hxx>
91 #include <drawinglayer/primitive2d/polygonprimitive2d.hxx>
92 #include <drawinglayer/primitive2d/textlayoutdevice.hxx>
93 #include <drawinglayer/primitive2d/groupprimitive2d.hxx>
94 #include <svx/sdr/contact/objectcontact.hxx>
95 #include <svx/sdr/table/tablecontroller.hxx>
96 #include <basegfx/matrix/b2dhommatrix.hxx>
97 #include <drawinglayer/primitive2d/textprimitive2d.hxx>
98 #include <svx/unoapi.hxx>
99 #include <basegfx/matrix/b2dhommatrixtools.hxx>
100 #include "DrawController.hxx"
101 
102 #include <numeric>
103 
104 using namespace com::sun::star;
105 using namespace com::sun::star::uno;
106 using namespace sdr::table;
107 namespace sd {
108 
109 #ifndef SO2_DECL_SVINPLACEOBJECT_DEFINED
110 #define SO2_DECL_SVINPLACEOBJECT_DEFINED
111 SO2_DECL_REF(SvInPlaceObject)
112 #endif
113 
114 TYPEINIT1(View, FmFormView);
115 
116 /*************************************************************************
117 |*
118 |* Ctor
119 |*
120 \************************************************************************/
121 
View(SdDrawDocument * pDrawDoc,OutputDevice * pOutDev,ViewShell * pViewShell)122 View::View(SdDrawDocument* pDrawDoc, OutputDevice* pOutDev,
123 			   ViewShell* pViewShell)
124   : FmFormView(pDrawDoc, pOutDev),
125 	mpDoc(pDrawDoc),
126 	mpDocSh( pDrawDoc->GetDocSh() ),
127 	mpViewSh(pViewShell),
128 	mpDragSrcMarkList(NULL),
129 	mpDropMarkerObj(NULL),
130 	mpDropMarker(NULL),
131 	mnDragSrcPgNum(SDRPAGE_NOTFOUND),
132 	mnAction(DND_ACTION_NONE),
133 	mnLockRedrawSmph(0),
134 	mpLockedRedraws(NULL),
135 	mbIsDropAllowed(sal_True),
136 	maSmartTags(*this),
137     mpClipboard (new ViewClipboard (*this))
138 {
139 	// #i73602# Use default from the configuration
140 	SetBufferedOverlayAllowed(getOptionsDrawinglayer().IsOverlayBuffer_DrawImpress());
141 
142 	// #i74769#, #i75172# Use default from the configuration
143 	SetBufferedOutputAllowed(getOptionsDrawinglayer().IsPaintBuffer_DrawImpress());
144 
145 	EnableExtendedKeyInputDispatcher(sal_False);
146 	EnableExtendedMouseEventDispatcher(sal_False);
147 	EnableExtendedCommandEventDispatcher(sal_False);
148 
149 	SetUseIncompatiblePathCreateInterface(sal_False);
150 	SetMarkHdlWhenTextEdit(sal_True);
151 	EnableTextEditOnObjectsWithoutTextIfTextTool(sal_True);
152 
153 	SetMinMoveDistancePixel(2);
154 	SetHitTolerancePixel(2);
155 	SetMeasureLayer(String(SdResId(STR_LAYER_MEASURELINES)));
156 
157 	// Timer fuer verzoegertes Drop (muss fuer MAC sein)
158 	maDropErrorTimer.SetTimeoutHdl( LINK(this, View, DropErrorHdl) );
159 	maDropErrorTimer.SetTimeout(50);
160 	maDropInsertFileTimer.SetTimeoutHdl( LINK(this, View, DropInsertFileHdl) );
161 	maDropInsertFileTimer.SetTimeout(50);
162 }
163 
ImplClearDrawDropMarker()164 void View::ImplClearDrawDropMarker()
165 {
166 	if(mpDropMarker)
167 	{
168 		delete mpDropMarker;
169 		mpDropMarker = 0L;
170 	}
171 }
172 
173 /*************************************************************************
174 |*
175 |* Dtor
176 |*
177 \************************************************************************/
178 
~View()179 View::~View()
180 {
181 	maSmartTags.Dispose();
182 
183 	// release content of selection clipboard, if we own the content
184     UpdateSelectionClipboard( sal_True );
185 
186 	maDropErrorTimer.Stop();
187 	maDropInsertFileTimer.Stop();
188 
189 	ImplClearDrawDropMarker();
190 
191 	while(PaintWindowCount())
192 	{
193 		// Alle angemeldeten OutDevs entfernen
194 		DeleteWindowFromPaintView(GetFirstOutputDevice() /*GetWin(0)*/);
195 	}
196 
197 	// gespeicherte Redraws loeschen
198 	if (mpLockedRedraws)
199 	{
200 		SdViewRedrawRec* pRec = (SdViewRedrawRec*)mpLockedRedraws->First();
201 		while (pRec)
202 		{
203 			delete pRec;
204 			pRec = (SdViewRedrawRec*)mpLockedRedraws->Next();
205 		}
206 		delete mpLockedRedraws;
207 	}
208 }
209 
210 
211 class ViewRedirector : public ::sdr::contact::ViewObjectContactRedirector
212 {
213 public:
214 	ViewRedirector();
215 	virtual ~ViewRedirector();
216 
217 	// all default implementations just call the same methods at the original. To do something
218 	// different, overload the method and at least do what the method does.
219 	virtual drawinglayer::primitive2d::Primitive2DSequence createRedirectedPrimitive2DSequence(
220 		const sdr::contact::ViewObjectContact& rOriginal,
221 		const sdr::contact::DisplayInfo& rDisplayInfo);
222 };
223 
ViewRedirector()224 ViewRedirector::ViewRedirector()
225 {
226 }
227 
~ViewRedirector()228 ViewRedirector::~ViewRedirector()
229 {
230 }
231 
createRedirectedPrimitive2DSequence(const sdr::contact::ViewObjectContact & rOriginal,const sdr::contact::DisplayInfo & rDisplayInfo)232 drawinglayer::primitive2d::Primitive2DSequence ViewRedirector::createRedirectedPrimitive2DSequence(
233 	const sdr::contact::ViewObjectContact& rOriginal,
234 	const sdr::contact::DisplayInfo& rDisplayInfo)
235 {
236 	SdrObject* pObject = rOriginal.GetViewContact().TryToGetSdrObject();
237 	drawinglayer::primitive2d::Primitive2DSequence xRetval;
238 
239 	if(pObject && pObject->GetPage())
240 	{
241 		const bool bDoCreateGeometry(pObject->GetPage()->checkVisibility( rOriginal, rDisplayInfo, true ));
242 
243 		if(!bDoCreateGeometry && !(( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_PAGE )) )
244 			return xRetval;
245 
246 		PresObjKind eKind(PRESOBJ_NONE);
247 		const bool bSubContentProcessing(rDisplayInfo.GetSubContentActive());
248 		const bool bIsMasterPageObject(pObject->GetPage()->IsMasterPage());
249 		const bool bIsPrinting(rOriginal.GetObjectContact().isOutputToPrinter());
250 		const SdrPageView* pPageView = rOriginal.GetObjectContact().TryToGetSdrPageView();
251         const SdrPage* pVisualizedPage = GetSdrPageFromXDrawPage(rOriginal.GetObjectContact().getViewInformation2D().getVisualizedPage());
252 		const SdPage* pObjectsSdPage = dynamic_cast< SdPage* >(pObject->GetPage());
253 		const bool bIsInsidePageObj(pPageView && pPageView->GetPage() != pVisualizedPage);
254 
255 		// check if we need to draw a placeholder border. Never do it for
256 		// objects inside a SdrPageObj and never when printing
257 		if(!bIsInsidePageObj && !bIsPrinting)
258 		{
259 			bool bCreateOutline(false);
260 
261 			if( pObject->IsEmptyPresObj() && pObject->ISA(SdrTextObj) )
262 			{
263 				if( !bSubContentProcessing || !pObject->IsNotVisibleAsMaster() )
264 				{
265 					eKind = pObjectsSdPage ? pObjectsSdPage->GetPresObjKind(pObject) : PRESOBJ_NONE;
266 					bCreateOutline = true;
267 				}
268 			}
269 			else if( ( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_TEXT ) )
270 			{
271 				if( pObjectsSdPage )
272 				{
273 					eKind = pObjectsSdPage->GetPresObjKind(pObject);
274 
275 					if((eKind == PRESOBJ_FOOTER) || (eKind == PRESOBJ_HEADER) || (eKind == PRESOBJ_DATETIME) || (eKind == PRESOBJ_SLIDENUMBER) )
276 					{
277 						if( !bSubContentProcessing )
278 						{
279 							// only draw a boundary for header&footer objects on the masterpage itself
280 							bCreateOutline = true;
281 						}
282 					}
283 				}
284 			}
285 			else if( ( pObject->GetObjInventor() == SdrInventor ) && ( pObject->GetObjIdentifier() == OBJ_PAGE ) )
286 			{
287 				// only for handout page, else this frame will be created for each
288 				// page preview object in SlideSorter and PagePane
289 				if(pObjectsSdPage && PK_HANDOUT == pObjectsSdPage->GetPageKind())
290 				{
291 					bCreateOutline = true;
292 				}
293 			}
294 
295 			if(bCreateOutline)
296 			{
297 				// empty presentation objects get a gray frame
298 				const svtools::ColorConfig aColorConfig;
299 				const svtools::ColorConfigValue aColor( aColorConfig.GetColorValue( svtools::OBJECTBOUNDARIES ) );
300 
301 				if( aColor.bIsVisible )
302 				{
303 					// get basic object transformation
304 					const basegfx::BColor aRGBColor(Color(aColor.nColor).getBColor());
305 					basegfx::B2DHomMatrix aObjectMatrix;
306 					basegfx::B2DPolyPolygon aObjectPolyPolygon;
307 					pObject->TRGetBaseGeometry(aObjectMatrix, aObjectPolyPolygon);
308 
309 					// create dashed border
310 					{
311 						// create object polygon
312 						basegfx::B2DPolygon aPolygon(basegfx::tools::createUnitPolygon());
313 						aPolygon.transform(aObjectMatrix);
314 
315 						// create line and stroke attribute
316 						::std::vector< double > aDotDashArray;
317 
318 						aDotDashArray.push_back(160.0);
319 						aDotDashArray.push_back(80.0);
320 
321 						const double fFullDotDashLen(::std::accumulate(aDotDashArray.begin(), aDotDashArray.end(), 0.0));
322 						const drawinglayer::attribute::LineAttribute aLine(aRGBColor);
323 						const drawinglayer::attribute::StrokeAttribute aStroke(aDotDashArray, fFullDotDashLen);
324 
325 						// create primitive and add
326 						const drawinglayer::primitive2d::Primitive2DReference xRef(new drawinglayer::primitive2d::PolygonStrokePrimitive2D(
327 							aPolygon,
328 							aLine,
329 							aStroke));
330 						drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval, xRef);
331 					}
332 
333 					// now paint the placeholder description, but only when masterpage
334 					// is displayed as page directly (MasterPage view)
335 					if(!bSubContentProcessing && bIsMasterPageObject)
336 					{
337 						String aObjectString;
338 
339 						switch( eKind )
340 						{
341 							case PRESOBJ_TITLE:
342 							{
343 								if(pObjectsSdPage && pObjectsSdPage->GetPageKind() == PK_STANDARD)
344 								{
345 									static String aTitleAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_TITLE ) );
346 									aObjectString = aTitleAreaStr;
347 								}
348 
349 								break;
350 							}
351 							case PRESOBJ_OUTLINE:
352 							{
353 								static String aOutlineAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_OUTLINE ) );
354 								aObjectString = aOutlineAreaStr;
355 								break;
356 							}
357 							case PRESOBJ_FOOTER:
358 							{
359 								static String aFooterAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_FOOTER ) );
360 								aObjectString = aFooterAreaStr;
361 								break;
362 							}
363 							case PRESOBJ_HEADER:
364 							{
365 								static String aHeaderAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_HEADER ) );
366 								aObjectString = aHeaderAreaStr;
367 								break;
368 							}
369 							case PRESOBJ_DATETIME:
370 							{
371 								static String aDateTimeStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_DATETIME ) );
372 								aObjectString = aDateTimeStr;
373 								break;
374 							}
375 							case PRESOBJ_NOTES:
376 							{
377 								static String aDateTimeStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_NOTES ) );
378 								aObjectString = aDateTimeStr;
379 								break;
380 							}
381 							case PRESOBJ_SLIDENUMBER:
382 							{
383 								if(pObjectsSdPage && pObjectsSdPage->GetPageKind() == PK_STANDARD)
384 								{
385 									static String aSlideAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_SLIDE ) );
386 									aObjectString = aSlideAreaStr;
387 								}
388 								else
389 								{
390 									static String aNumberAreaStr( SdResId( STR_PLACEHOLDER_DESCRIPTION_NUMBER ) );
391 									aObjectString = aNumberAreaStr;
392 								}
393 								break;
394 							}
395 							default:
396 							{
397 								break;
398 							}
399 						}
400 
401 						if( aObjectString.Len() )
402 						{
403 							// decompose object matrix to be able to place text correctly
404 							basegfx::B2DTuple aScale;
405 							basegfx::B2DTuple aTranslate;
406 							double fRotate, fShearX;
407 							aObjectMatrix.decompose(aScale, aTranslate, fRotate, fShearX);
408 
409 							// create font
410 							SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( pObject );
411 							const SdrTextVertAdjust eTVA(pTextObj ? pTextObj->GetTextVerticalAdjust() : SDRTEXTVERTADJUST_CENTER);
412 							Font aScaledVclFont;
413 
414 							// use a text size factor to get more reliable text sizes from the text layouter
415 							// (and from vcl), tipp from HDU
416 							static sal_uInt32 nTextSizeFactor(100);
417 
418 							// use a factor to get more linear text size calculations
419 							aScaledVclFont.SetHeight( 500 * nTextSizeFactor );
420 
421 							// get basic geometry and get text size
422 							drawinglayer::primitive2d::TextLayouterDevice aTextLayouter;
423 							aTextLayouter.setFont(aScaledVclFont);
424 							const xub_StrLen nTextLength(aObjectString.Len());
425 
426 							// do not forget to use the factor again to get the width for the 500
427 							const double fTextWidth(aTextLayouter.getTextWidth(aObjectString, 0, nTextLength) * (1.0 / nTextSizeFactor));
428 							const double fTextHeight(aTextLayouter.getTextHeight() * (1.0 / nTextSizeFactor));
429 
430 							// calculate text primitive position. If text is at bottom, use top for
431 							// the extra text and vice versa
432 							const double fHorDist(125);
433 							const double fVerDist(125);
434 							const double fPosX((aTranslate.getX() + aScale.getX()) - fTextWidth - fHorDist);
435 							const double fPosY((SDRTEXTVERTADJUST_BOTTOM == eTVA)
436 								? aTranslate.getY() - fVerDist + fTextHeight
437 								: (aTranslate.getY() + aScale.getY()) - fVerDist);
438 
439 							// get font attributes; use normally scaled font
440 							const basegfx::BColor aFontColor(aRGBColor);
441 							Font aVclFont;
442 							basegfx::B2DVector aTextSizeAttribute;
443 
444 							aVclFont.SetHeight( 500 );
445 
446 							const drawinglayer::attribute::FontAttribute aFontAttribute(
447                                 drawinglayer::primitive2d::getFontAttributeFromVclFont(
448 								    aTextSizeAttribute,
449 								    aVclFont,
450 								    false,
451 								    false));
452 
453 							// fill text matrix
454 							const basegfx::B2DHomMatrix aTextMatrix(basegfx::tools::createScaleShearXRotateTranslateB2DHomMatrix(
455 								aTextSizeAttribute.getX(), aTextSizeAttribute.getY(),
456 								fShearX,
457                                 fRotate,
458                                 fPosX, fPosY));
459 
460 							// create DXTextArray (can be empty one)
461 							const ::std::vector< double > aDXArray;
462 
463 							// create locale; this may need some more information in the future
464 							const ::com::sun::star::lang::Locale aLocale;
465 
466 							// create primitive and add
467 							const drawinglayer::primitive2d::Primitive2DReference xRef(
468                                 new drawinglayer::primitive2d::TextSimplePortionPrimitive2D(
469 								    aTextMatrix,
470 								    aObjectString,
471 								    0,
472 								    nTextLength,
473 								    aDXArray,
474 								    aFontAttribute,
475 								    aLocale,
476 								    aFontColor));
477 							drawinglayer::primitive2d::appendPrimitive2DReferenceToPrimitive2DSequence(xRetval, xRef);
478 						}
479 					}
480 				}
481 			}
482 		}
483 
484 		if(bDoCreateGeometry)
485 		{
486 			drawinglayer::primitive2d::appendPrimitive2DSequenceToPrimitive2DSequence(
487 				xRetval,
488 				sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(
489 					rOriginal,
490 					rDisplayInfo));
491 		}
492 	}
493 	else
494 	{
495 		// not a SdrObject visualisation (maybe e.g. page) or no page
496 		xRetval = sdr::contact::ViewObjectContactRedirector::createRedirectedPrimitive2DSequence(rOriginal, rDisplayInfo);
497 	}
498 
499 	return xRetval;
500 }
501 
502 /*************************************************************************
503 |*
504 |* Paint-Methode: das Ereignis wird an die View weitergeleitet
505 |*
506 \************************************************************************/
507 
CompleteRedraw(OutputDevice * pOutDev,const Region & rReg,sdr::contact::ViewObjectContactRedirector * pRedirector)508 void View::CompleteRedraw(OutputDevice* pOutDev, const Region& rReg, sdr::contact::ViewObjectContactRedirector* pRedirector /*=0L*/)
509 {
510 	// ausfuehren ??
511 	if (mnLockRedrawSmph == 0)
512 	{
513 		SdrPageView* pPgView = GetSdrPageView();
514 
515 		if (pPgView)
516 		{
517 			SdPage* pPage = (SdPage*) pPgView->GetPage();
518 			if( pPage )
519 			{
520 				SdrOutliner& rOutl=mpDoc->GetDrawOutliner(NULL);
521                 bool bScreenDisplay(true);
522 
523                 if(bScreenDisplay && pOutDev && OUTDEV_PRINTER == pOutDev->GetOutDevType())
524                 {
525                     // #i75566# printing; suppress AutoColor BackgroundColor generation
526                     // for visibility reasons by giving GetPageBackgroundColor()
527                     // the needed hint
528                     bScreenDisplay = false;
529                 }
530 
531                 if(bScreenDisplay && pOutDev && pOutDev->GetPDFWriter())
532                 {
533                     // #i75566# PDF export; suppress AutoColor BackgroundColor generation (see above)
534                     bScreenDisplay = false;
535                 }
536 
537                 // #i75566# Name change GetBackgroundColor -> GetPageBackgroundColor and
538                 // hint value if screen display. Only then the AutoColor mechanisms shall be applied
539 				rOutl.SetBackgroundColor( pPage->GetPageBackgroundColor(pPgView, bScreenDisplay) );
540 			}
541 		}
542 
543 		ViewRedirector aViewRedirector;
544 		FmFormView::CompleteRedraw(pOutDev, rReg, pRedirector ? pRedirector : &aViewRedirector);
545 	}
546 	// oder speichern?
547 	else
548 	{
549 		if (!mpLockedRedraws)
550 			mpLockedRedraws = new List;
551 
552 		SdViewRedrawRec* pRec = new SdViewRedrawRec;
553 		pRec->mpOut	= pOutDev;
554 		pRec->aRect = rReg.GetBoundRect();
555 		mpLockedRedraws->Insert(pRec, LIST_APPEND);
556 	}
557 }
558 
559 
560 /*************************************************************************
561 |*
562 |* Selektion hat sich geaendert
563 |*
564 \************************************************************************/
565 
MarkListHasChanged()566 void View::MarkListHasChanged()
567 {
568 	FmFormView::MarkListHasChanged();
569 
570 	if( GetMarkedObjectCount() > 0 )
571 		maSmartTags.deselect();
572 }
573 
574 
575 /*************************************************************************
576 |*
577 |* Attribute setzen
578 |*
579 \************************************************************************/
580 
SetAttributes(const SfxItemSet & rSet,sal_Bool bReplaceAll)581 sal_Bool View::SetAttributes(const SfxItemSet& rSet, sal_Bool bReplaceAll)
582 {
583 	sal_Bool bOk = FmFormView::SetAttributes(rSet, bReplaceAll);
584 	return (bOk);
585 }
586 
587 
588 /*************************************************************************
589 |*
590 |* Attribute holen
591 |*
592 \************************************************************************/
593 
GetAttributes(SfxItemSet & rTargetSet,sal_Bool bOnlyHardAttr) const594 sal_Bool View::GetAttributes( SfxItemSet& rTargetSet, sal_Bool bOnlyHardAttr ) const
595 {
596 	return( FmFormView::GetAttributes( rTargetSet, bOnlyHardAttr ) );
597 }
598 
599 
600 /*************************************************************************
601 |*
602 |* Ist ein Praesentationsobjekt selektiert?
603 |*
604 \************************************************************************/
605 
IsPresObjSelected(sal_Bool bOnPage,sal_Bool bOnMasterPage,sal_Bool bCheckPresObjListOnly,sal_Bool bCheckLayoutOnly) const606 sal_Bool View::IsPresObjSelected(sal_Bool bOnPage, sal_Bool bOnMasterPage, sal_Bool bCheckPresObjListOnly, sal_Bool bCheckLayoutOnly) const
607 {
608 	/**************************************************************************
609 	* Ist ein Presentationsobjekt selektiert?
610 	**************************************************************************/
611 	SdrMarkList* pMarkList;
612 
613 	if (mnDragSrcPgNum != SDRPAGE_NOTFOUND &&
614 		mnDragSrcPgNum != GetSdrPageView()->GetPage()->GetPageNum())
615 	{
616 		// Es laeuft gerade Drag&Drop
617 		// Source- und Destination-Page unterschiedlich:
618 		// es wird die gemerkte MarkList verwendet
619 		pMarkList = mpDragSrcMarkList;
620 	}
621 	else
622 	{
623 		// Es wird die aktuelle MarkList verwendet
624 		pMarkList = new SdrMarkList(GetMarkedObjectList());
625 	}
626 
627 	SdrMark* pMark;
628 	SdPage* pPage;
629 	SdrObject* pObj;
630 
631 	sal_Bool bSelected = sal_False;
632 	sal_Bool bMasterPage = sal_False;
633 	long nMark;
634 	long nMarkMax = long(pMarkList->GetMarkCount()) - 1;
635 
636 	for (nMark = nMarkMax; (nMark >= 0) && !bSelected; nMark--)
637 	{
638 		// Rueckwaerts durch die Marklist
639 		pMark = pMarkList->GetMark(nMark);
640 		pObj = pMark->GetMarkedSdrObj();
641 
642 		if ( pObj && ( bCheckPresObjListOnly || pObj->IsEmptyPresObj() || pObj->GetUserCall() ) )
643 		{
644 			pPage = (SdPage*) pObj->GetPage();
645 			bMasterPage = pPage->IsMasterPage();
646 
647 			if ( (bMasterPage && bOnMasterPage) || (!bMasterPage && bOnPage) )
648 			{
649 				if ( pPage && pPage->IsPresObj(pObj) )
650 				{
651 					if( bCheckLayoutOnly )
652 					{
653 						PresObjKind eKind = pPage->GetPresObjKind(pObj);
654 
655 						if((eKind != PRESOBJ_FOOTER) && (eKind != PRESOBJ_HEADER) && (eKind != PRESOBJ_DATETIME) && (eKind != PRESOBJ_SLIDENUMBER) )
656 							bSelected = sal_True;
657 					}
658 					else
659 					{
660 						bSelected = sal_True;
661 					}
662 				}
663 			}
664 		}
665 	}
666 
667 	if (pMarkList != mpDragSrcMarkList)
668 	{
669 	   delete pMarkList;
670 	}
671 
672 	return (bSelected);
673 }
674 
675 /*************************************************************************
676 |*
677 |* Alles selektieren
678 |*
679 \************************************************************************/
680 
SelectAll()681 void View::SelectAll()
682 {
683 	if ( IsTextEdit() )
684 	{
685 		OutlinerView* pOLV = GetTextEditOutlinerView();
686 		const ::Outliner* pOutliner = GetTextEditOutliner();
687 		pOLV->SelectRange( 0, pOutliner->GetParagraphCount() );
688 	}
689 	else
690 	{
691 		MarkAll();
692 	}
693 }
694 
695 
696 /*************************************************************************
697 |*
698 |* Dokument hat sich geaendert
699 |*
700 \************************************************************************/
701 
ModelHasChanged()702 void View::ModelHasChanged()
703 {
704 	// Erst SdrView benachrichtigen
705 	FmFormView::ModelHasChanged();
706 }
707 
708 /*************************************************************************
709 |*
710 |* StyleSheet setzen
711 |*
712 \************************************************************************/
713 
SetStyleSheet(SfxStyleSheet * pStyleSheet,sal_Bool bDontRemoveHardAttr)714 sal_Bool View::SetStyleSheet(SfxStyleSheet* pStyleSheet, sal_Bool bDontRemoveHardAttr)
715 {
716 	// weiter an SdrView
717 	return FmFormView::SetStyleSheet(pStyleSheet, bDontRemoveHardAttr);
718 }
719 
720 
721 /*************************************************************************
722 |*
723 |* Texteingabe beginnen
724 |*
725 \************************************************************************/
726 
SetSpellOptions(SdDrawDocument * pDoc,sal_uLong & rCntrl)727 static void SetSpellOptions( SdDrawDocument* pDoc, sal_uLong& rCntrl )
728 {
729 	sal_Bool bOnlineSpell = pDoc->GetOnlineSpell();
730 
731 	if( bOnlineSpell )
732 		rCntrl |= EE_CNTRL_ONLINESPELLING;
733 	else
734 		rCntrl &= ~EE_CNTRL_ONLINESPELLING;
735 }
736 
SdrBeginTextEdit(SdrObject * pObj,SdrPageView * pPV,::Window * pWin,sal_Bool bIsNewObj,SdrOutliner * pOutl,OutlinerView * pGivenOutlinerView,sal_Bool bDontDeleteOutliner,sal_Bool bOnlyOneView,sal_Bool bGrabFocus)737 sal_Bool View::SdrBeginTextEdit(
738 	SdrObject* pObj, SdrPageView* pPV, ::Window* pWin,
739 	sal_Bool bIsNewObj,
740 	SdrOutliner* pOutl, OutlinerView* pGivenOutlinerView,
741     sal_Bool bDontDeleteOutliner, sal_Bool bOnlyOneView, sal_Bool bGrabFocus )
742 {
743 	GetViewShell()->GetViewShellBase().GetEventMultiplexer()->MultiplexEvent(
744         sd::tools::EventMultiplexerEvent::EID_BEGIN_TEXT_EDIT, (void*)pObj );
745 
746 	if( pOutl==NULL && pObj )
747 		pOutl = SdrMakeOutliner( OUTLINERMODE_TEXTOBJECT, pObj->GetModel() );
748 
749 	// make draw&impress specific initialisations
750 	if( pOutl )
751 	{
752 		pOutl->SetStyleSheetPool((SfxStyleSheetPool*) mpDoc->GetStyleSheetPool());
753 		pOutl->SetCalcFieldValueHdl(LINK(SD_MOD(), SdModule, CalcFieldValueHdl));
754 		sal_uLong nCntrl = pOutl->GetControlWord();
755 		nCntrl |= EE_CNTRL_ALLOWBIGOBJS;
756 		nCntrl |= EE_CNTRL_URLSFXEXECUTE;
757 		nCntrl |= EE_CNTRL_MARKFIELDS;
758 		nCntrl |= EE_CNTRL_AUTOCORRECT;
759 
760 		nCntrl &= ~EE_CNTRL_ULSPACESUMMATION;
761 		if ( mpDoc->IsSummationOfParagraphs() )
762 		    nCntrl |= EE_CNTRL_ULSPACESUMMATION;
763 
764 		SetSpellOptions( mpDoc, nCntrl );
765 
766 		pOutl->SetControlWord(nCntrl);
767 
768 		Reference< linguistic2::XSpellChecker1 > xSpellChecker( LinguMgr::GetSpellChecker() );
769         if ( xSpellChecker.is() )
770             pOutl->SetSpeller( xSpellChecker );
771 
772 		Reference< linguistic2::XHyphenator > xHyphenator( LinguMgr::GetHyphenator() );
773         if( xHyphenator.is() )
774             pOutl->SetHyphenator( xHyphenator );
775 
776 		pOutl->SetDefaultLanguage( Application::GetSettings().GetLanguage() );
777 	}
778 
779 	sal_Bool bReturn = FmFormView::SdrBeginTextEdit(
780 		pObj, pPV, pWin, bIsNewObj, pOutl,
781 		pGivenOutlinerView, bDontDeleteOutliner,
782 		bOnlyOneView, bGrabFocus);
783 
784     if ( mpViewSh )
785     {
786         mpViewSh->GetViewShellBase().GetDrawController().FireSelectionChangeListener();
787     }
788 
789     if (bReturn)
790     {
791         ::Outliner* pOL = GetTextEditOutliner();
792 
793         if( pObj && pObj->GetPage() )
794         {
795             Color aBackground;
796             if( pObj->GetObjInventor() == SdrInventor && pObj->GetObjIdentifier() == OBJ_TABLE )
797             {
798                 aBackground = GetTextEditBackgroundColor(*this);
799             }
800             else
801             {
802                 aBackground = pObj->GetPage()->GetPageBackgroundColor(pPV);
803             }
804             if (pOL != NULL)
805                 pOL->SetBackgroundColor( aBackground  );
806         }
807 
808         if (pOL != NULL)
809         {
810             pOL->SetParaInsertedHdl(LINK(this, View, OnParagraphInsertedHdl));
811             pOL->SetParaRemovingHdl(LINK(this, View, OnParagraphRemovingHdl));
812         }
813     }
814 
815     return(bReturn);
816 }
817 
818 /** ends current text editing */
SdrEndTextEdit(sal_Bool bDontDeleteReally)819 SdrEndTextEditKind View::SdrEndTextEdit(sal_Bool bDontDeleteReally )
820 {
821 	SdrObjectWeakRef xObj( GetTextEditObject() );
822 
823 	sal_Bool bDefaultTextRestored = RestoreDefaultText( dynamic_cast< SdrTextObj* >( GetTextEditObject() ) );
824 
825 	SdrEndTextEditKind eKind = FmFormView::SdrEndTextEdit(bDontDeleteReally);
826 
827 	if( bDefaultTextRestored )
828 	{
829 		if( xObj.is() && !xObj->IsEmptyPresObj() )
830 		{
831 			xObj->SetEmptyPresObj( sal_True );
832 		}
833 		else
834 		{
835 			eKind = SDRENDTEXTEDIT_UNCHANGED;
836 		}
837 	}
838 	else if( xObj.is() && xObj->IsEmptyPresObj() )
839 	{
840 		SdrTextObj* pObj = dynamic_cast< SdrTextObj* >( xObj.get() );
841 		if( pObj && pObj->HasText() )
842 		{
843 			SdrPage* pPage = pObj->GetPage();
844 			if( !pPage || !pPage->IsMasterPage() )
845 				pObj->SetEmptyPresObj( sal_False );
846 		}
847 	}
848 
849     GetViewShell()->GetViewShellBase().GetEventMultiplexer()->MultiplexEvent(
850         sd::tools::EventMultiplexerEvent::EID_END_TEXT_EDIT,
851         (void*)xObj.get() );
852 
853     if( xObj.is() )
854     {
855         if ( mpViewSh )
856         {
857             mpViewSh->GetViewShellBase().GetDrawController().FireSelectionChangeListener();
858         }
859 
860         SdPage* pPage = dynamic_cast< SdPage* >( xObj->GetPage() );
861         if( pPage )
862             pPage->onEndTextEdit( xObj.get() );
863     }
864 
865     return(eKind);
866 }
867 
868 // --------------------------------------------------------------------
869 
870 /** restores the default text if the given text object is currently in edit mode and
871 	no text has been entered already. Is only useful just before text edit ends. */
RestoreDefaultText(SdrTextObj * pTextObj)872 bool View::RestoreDefaultText( SdrTextObj* pTextObj )
873 {
874 	bool bRestored = false;
875 
876 	if( pTextObj && (pTextObj == GetTextEditObject()) )
877 	{
878 		if( !pTextObj->HasText() )
879 		{
880 			SdPage* pPage = dynamic_cast< SdPage* >( pTextObj->GetPage() );
881 
882 			if(pPage)
883 			{
884 				bRestored = pPage->RestoreDefaultText( pTextObj );
885 				if( bRestored )
886 				{
887 					SdrOutliner* pOutliner = GetTextEditOutliner();
888 					pTextObj->SetTextEditOutliner( pOutliner );
889 					OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
890 					if (pOutliner)
891 						pOutliner->SetText(*pParaObj);
892 				}
893 			}
894 		}
895 	}
896 
897 	return bRestored;
898 }
899 
900 /*************************************************************************
901 |*
902 |* Originalgroesse der markierten Objekte setzen
903 |*
904 \************************************************************************/
905 
SetMarkedOriginalSize()906 void View::SetMarkedOriginalSize()
907 {
908 	SdrUndoGroup*   pUndoGroup = new SdrUndoGroup(*mpDoc);
909 	sal_uLong           nCount = GetMarkedObjectCount();
910 	sal_Bool            bOK = sal_False;
911 
912 	for( sal_uInt32 i = 0; i < nCount; i++ )
913 	{
914 		SdrObject* pObj = GetMarkedObjectByIndex(i);
915 
916 		if( pObj->GetObjInventor() == SdrInventor )
917 		{
918 			if( pObj->GetObjIdentifier() == OBJ_OLE2 )
919 			{
920                 uno::Reference < embed::XEmbeddedObject > xObj = ((SdrOle2Obj*)pObj)->GetObjRef();
921                 if( xObj.is() )
922 				{
923                     // TODO/LEAN: working with VisualArea can switch object to running state
924 
925                    	sal_Int64 nAspect = ((SdrOle2Obj*)pObj)->GetAspect();
926 					Size aOleSize;
927 
928 					if ( nAspect == embed::Aspects::MSOLE_ICON )
929 					{
930 						MapMode aMap100( MAP_100TH_MM );
931                     	aOleSize = ((SdrOle2Obj*)pObj)->GetOrigObjSize( &aMap100 );
932                     	bOK = sal_True;
933 					}
934 					else
935 					{
936                     	MapUnit aUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( nAspect ) );
937 						try
938 						{
939                     		awt::Size aSz = xObj->getVisualAreaSize( nAspect );
940                     		aOleSize = OutputDevice::LogicToLogic( Size( aSz.Width, aSz.Height ), aUnit, MAP_100TH_MM );
941                     		bOK = sal_True;
942 						}
943 						catch( embed::NoVisualAreaSizeException& )
944 						{}
945 					}
946 
947 					if ( bOK )
948 					{
949 						Rectangle   aDrawRect( pObj->GetLogicRect() );
950 
951 						pUndoGroup->AddAction( mpDoc->GetSdrUndoFactory().CreateUndoGeoObject( *pObj ) );
952 						pObj->Resize( aDrawRect.TopLeft(), Fraction( aOleSize.Width(), aDrawRect.GetWidth() ),
953 													   	Fraction( aOleSize.Height(), aDrawRect.GetHeight() ) );
954 					}
955                 }
956 			}
957 			else if( pObj->GetObjIdentifier() == OBJ_GRAF )
958 			{
959 				const MapMode   aMap100( MAP_100TH_MM );
960 				Size            aSize;
961 
962 			    if ( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefMapMode().GetMapUnit() == MAP_PIXEL )
963 				    aSize = Application::GetDefaultDevice()->PixelToLogic( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefSize(), aMap100 );
964 			    else
965 			    {
966 				    aSize = OutputDevice::LogicToLogic( static_cast< SdrGrafObj* >( pObj )->GetGrafPrefSize(),
967 														static_cast< SdrGrafObj* >( pObj )->GetGrafPrefMapMode(),
968 														aMap100 );
969 				}
970 
971 				pUndoGroup->AddAction( GetModel()->GetSdrUndoFactory().CreateUndoGeoObject(*pObj ) );
972 				Rectangle aRect( pObj->GetLogicRect() );
973 				aRect.SetSize( aSize );
974 				pObj->SetLogicRect( aRect );
975 
976 				bOK = sal_True;
977 			}
978 		}
979 	}
980 
981 	if( bOK )
982 	{
983 		pUndoGroup->SetComment( String(SdResId(STR_UNDO_ORIGINALSIZE)) );
984 		mpDocSh->GetUndoManager()->AddUndoAction(pUndoGroup);
985 	}
986 	else
987 		delete pUndoGroup;
988 }
989 
990 /*************************************************************************
991 |*
992 |* OLE-Obj am Client connecten
993 |*
994 \************************************************************************/
995 
DoConnect(SdrOle2Obj * pObj)996 void View::DoConnect(SdrOle2Obj* pObj)
997 {
998 	if (mpViewSh)
999 	{
1000         uno::Reference < embed::XEmbeddedObject > xObj( pObj->GetObjRef() );
1001         if( xObj.is() )
1002 		{
1003             ::sd::Window* pWindow = mpViewSh->GetActiveWindow();
1004             SfxInPlaceClient* pSdClient = mpViewSh-> GetViewShellBase().FindIPClient( xObj, pWindow );
1005             if ( !pSdClient )
1006 			{
1007                 pSdClient = new Client(pObj, mpViewSh, pWindow);
1008 				Rectangle aRect = pObj->GetLogicRect();
1009 				{
1010                     // TODO/LEAN: working with visual area can switch object to running state
1011 					Size aDrawSize = aRect.GetSize();
1012                     awt::Size aSz;
1013 
1014 					MapMode aMapMode( mpDoc->GetScaleUnit() );
1015                     Size aObjAreaSize = pObj->GetOrigObjSize( &aMapMode );
1016 
1017 					Fraction aScaleWidth (aDrawSize.Width(),  aObjAreaSize.Width() );
1018 					Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() );
1019 					aScaleWidth.ReduceInaccurate(10);		// kompatibel zum SdrOle2Obj
1020 					aScaleHeight.ReduceInaccurate(10);
1021                     pSdClient->SetSizeScale(aScaleWidth, aScaleHeight);
1022 
1023 					// sichtbarer Ausschnitt wird nur inplace veraendert!
1024 					// the object area must be set after the scaling, since it triggers resize
1025 					aRect.SetSize(aObjAreaSize);
1026                     pSdClient->SetObjArea(aRect);
1027 				}
1028 			}
1029         }
1030 	}
1031 }
1032 
1033 /*************************************************************************
1034 |*
1035 |*
1036 |*
1037 \************************************************************************/
1038 
IsMorphingAllowed() const1039 sal_Bool View::IsMorphingAllowed() const
1040 {
1041 	const SdrMarkList&	rMarkList = GetMarkedObjectList();
1042 	sal_Bool				bRet = sal_False;
1043 
1044 	if ( rMarkList.GetMarkCount() == 2 )
1045 	{
1046 		const SdrObject*	pObj1 = rMarkList.GetMark( 0 )->GetMarkedSdrObj();
1047 		const SdrObject*	pObj2 = rMarkList.GetMark( 1 )->GetMarkedSdrObj();
1048 		const sal_uInt16		nKind1 = pObj1->GetObjIdentifier();
1049 		const sal_uInt16		nKind2 = pObj2->GetObjIdentifier();
1050 
1051 		if ( ( nKind1 != OBJ_TEXT && nKind2 != OBJ_TEXT ) &&
1052 			 ( nKind1 != OBJ_TITLETEXT && nKind2 != OBJ_TITLETEXT ) &&
1053 			 ( nKind1 != OBJ_OUTLINETEXT && nKind2 != OBJ_OUTLINETEXT ) &&
1054 			 ( nKind1 != OBJ_GRUP && nKind2 != OBJ_GRUP ) &&
1055 			 ( nKind1 != OBJ_LINE && nKind2 != OBJ_LINE ) &&
1056 			 ( nKind1 != OBJ_PLIN && nKind2 != OBJ_PLIN ) &&
1057 			 ( nKind1 != OBJ_PATHLINE && nKind2 != OBJ_PATHLINE ) &&
1058 			 ( nKind1 != OBJ_FREELINE && nKind2 != OBJ_FREELINE ) &&
1059 			 ( nKind1 != OBJ_PATHPLIN && nKind2 != OBJ_PATHPLIN ) &&
1060 			 ( nKind1 != OBJ_MEASURE && nKind2 != OBJ_MEASURE ) &&
1061 			 ( nKind1 != OBJ_EDGE && nKind2 != OBJ_EDGE ) &&
1062 			 ( nKind1 != OBJ_GRAF && nKind2 != OBJ_GRAF ) &&
1063 			 ( nKind1 != OBJ_OLE2 && nKind2 != OBJ_OLE2 ) &&
1064 			 ( nKind1 != OBJ_CAPTION && nKind2 !=  OBJ_CAPTION ) &&
1065 			 !pObj1->ISA( E3dObject) && !pObj2->ISA( E3dObject) )
1066 		{
1067 			SfxItemSet		aSet1( mpDoc->GetPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE );
1068 			SfxItemSet		aSet2( mpDoc->GetPool(), XATTR_FILLSTYLE, XATTR_FILLSTYLE );
1069 
1070 			aSet1.Put(pObj1->GetMergedItemSet());
1071 			aSet2.Put(pObj2->GetMergedItemSet());
1072 
1073 			const XFillStyle	eFillStyle1 = ( (const XFillStyleItem&) aSet1.Get( XATTR_FILLSTYLE ) ).GetValue();
1074 			const XFillStyle	eFillStyle2 = ( (const XFillStyleItem&) aSet2.Get( XATTR_FILLSTYLE ) ).GetValue();
1075 
1076 			if( ( eFillStyle1 == XFILL_NONE || eFillStyle1 == XFILL_SOLID ) &&
1077 				( eFillStyle2 == XFILL_NONE || eFillStyle2 == XFILL_SOLID ) )
1078 				bRet = sal_True;
1079 		}
1080 	}
1081 
1082 	return bRet;
1083 }
1084 
1085 /*************************************************************************
1086 |*
1087 |*
1088 |*
1089 \************************************************************************/
1090 
IsVectorizeAllowed() const1091 sal_Bool View::IsVectorizeAllowed() const
1092 {
1093 	const SdrMarkList&	rMarkList = GetMarkedObjectList();
1094 	sal_Bool				bRet = sal_False;
1095 
1096 	if( rMarkList.GetMarkCount() == 1 )
1097 	{
1098 		const SdrGrafObj* pObj = dynamic_cast< const SdrGrafObj* >(rMarkList.GetMark( 0 )->GetMarkedSdrObj());
1099 
1100         if(pObj)
1101         {
1102             if(GRAPHIC_BITMAP == pObj->GetGraphicType() && !pObj->isEmbeddedSvg())
1103             {
1104                 bRet = sal_True;
1105             }
1106         }
1107 	}
1108 
1109 	return bRet;
1110 }
1111 
onAccessibilityOptionsChanged()1112 void View::onAccessibilityOptionsChanged()
1113 {
1114 	if( mpViewSh )
1115 	{
1116 		::sd::Window* pWindow = mpViewSh->GetActiveWindow();
1117 		if( pWindow )
1118 		{
1119 			const StyleSettings& rStyleSettings = pWindow->GetSettings().GetStyleSettings();
1120 
1121 			sal_uInt16 nOutputSlot, nPreviewSlot;
1122 
1123 			SvtAccessibilityOptions& aAccOptions = getAccessibilityOptions();
1124 
1125 			if( mpViewSh->GetViewFrame() && mpViewSh->GetViewFrame()->GetDispatcher() )
1126 			{
1127 				if( rStyleSettings.GetHighContrastMode() )
1128 				{
1129 					nOutputSlot = SID_OUTPUT_QUALITY_CONTRAST;
1130 				}
1131 				else
1132 				{
1133 					nOutputSlot = SID_OUTPUT_QUALITY_COLOR;
1134 				}
1135 
1136 				if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForPagePreviews() )
1137 				{
1138 					nPreviewSlot = SID_PREVIEW_QUALITY_CONTRAST;
1139 				}
1140 				else
1141 				{
1142 					nPreviewSlot = SID_PREVIEW_QUALITY_COLOR;
1143 				}
1144 
1145 				mpViewSh->GetViewFrame()->GetDispatcher()->Execute( nOutputSlot, SFX_CALLMODE_ASYNCHRON );
1146 				mpViewSh->GetViewFrame()->GetDispatcher()->Execute( nPreviewSlot, SFX_CALLMODE_ASYNCHRON );
1147 			}
1148 
1149 			mpViewSh->Invalidate();
1150 		}
1151 	}
1152 }
1153 
IMPL_LINK(View,OnParagraphInsertedHdl,::Outliner *,pOutliner)1154 IMPL_LINK( View, OnParagraphInsertedHdl, ::Outliner *, pOutliner )
1155 {
1156 	Paragraph* pPara = pOutliner->GetHdlParagraph();
1157 	SdrObject* pObj = GetTextEditObject();
1158 
1159 	if( pPara && pObj )
1160 	{
1161 		SdPage* pPage = dynamic_cast< SdPage* >( pObj->GetPage() );
1162 		if( pPage )
1163 			pPage->onParagraphInserted( pOutliner, pPara, pObj );
1164 	}
1165 	return 0;
1166 }
1167 
1168 /*************************************************************************
1169 |*
1170 |* Handler fuer das Loeschen von Seiten (Absaetzen)
1171 |*
1172 \************************************************************************/
1173 
IMPL_LINK(View,OnParagraphRemovingHdl,::Outliner *,pOutliner)1174 IMPL_LINK( View, OnParagraphRemovingHdl, ::Outliner *, pOutliner )
1175 {
1176 	Paragraph* pPara = pOutliner->GetHdlParagraph();
1177 	SdrObject* pObj = GetTextEditObject();
1178 
1179 	if( pPara && pObj )
1180 	{
1181 		SdPage* pPage = dynamic_cast< SdPage* >( pObj->GetPage() );
1182 		if( pPage )
1183 			pPage->onParagraphRemoving( pOutliner, pPara, pObj );
1184 	}
1185 	return 0;
1186 }
1187 
isRecordingUndo() const1188 bool View::isRecordingUndo() const
1189 {
1190 	if( mpDoc && mpDoc->IsUndoEnabled() )
1191 	{
1192 		sd::UndoManager* pUndoManager = mpDoc ? mpDoc->GetUndoManager() : 0;
1193 		return pUndoManager && pUndoManager->IsInListAction();
1194 	}
1195 	else
1196 	{
1197 		return false;
1198 	}
1199 }
1200 
AddCustomHdl()1201 void View::AddCustomHdl()
1202 {
1203 	maSmartTags.addCustomHandles( aHdl );
1204 }
1205 
updateHandles()1206 void View::updateHandles()
1207 {
1208 	AdjustMarkHdl();
1209 }
1210 
GetContext() const1211 SdrViewContext View::GetContext() const
1212 {
1213 	SdrViewContext eContext = SDRCONTEXT_STANDARD;
1214 	if( maSmartTags.getContext( eContext ) )
1215 		return eContext;
1216 	else
1217 		return FmFormView::GetContext();
1218 }
1219 
HasMarkablePoints() const1220 sal_Bool View::HasMarkablePoints() const
1221 {
1222 	if( maSmartTags.HasMarkablePoints() )
1223 		return true;
1224 	else
1225 		return FmFormView::HasMarkablePoints();
1226 }
1227 
GetMarkablePointCount() const1228 sal_uLong View::GetMarkablePointCount() const
1229 {
1230 	sal_uLong nCount = FmFormView::GetMarkablePointCount();
1231 	nCount += maSmartTags.GetMarkablePointCount();
1232 	return nCount;
1233 }
1234 
HasMarkedPoints() const1235 sal_Bool View::HasMarkedPoints() const
1236 {
1237 	if( maSmartTags.HasMarkedPoints() )
1238 		return true;
1239 	else
1240 		return FmFormView::HasMarkedPoints();
1241 }
1242 
GetMarkedPointCount() const1243 sal_uLong View::GetMarkedPointCount() const
1244 {
1245 	sal_uLong nCount = FmFormView::GetMarkedPointCount();
1246 	nCount += maSmartTags.GetMarkedPointCount();
1247 	return nCount;
1248 }
1249 
IsPointMarkable(const SdrHdl & rHdl) const1250 sal_Bool View::IsPointMarkable(const SdrHdl& rHdl) const
1251 {
1252 	if( maSmartTags.IsPointMarkable( rHdl ) )
1253 		return true;
1254 	else
1255 		return FmFormView::IsPointMarkable( rHdl );
1256 }
1257 
MarkPoint(SdrHdl & rHdl,sal_Bool bUnmark)1258 sal_Bool View::MarkPoint(SdrHdl& rHdl, sal_Bool bUnmark )
1259 {
1260 	if( maSmartTags.MarkPoint( rHdl, bUnmark ) )
1261 		return true;
1262 	else
1263 		return FmFormView::MarkPoint( rHdl, bUnmark );
1264 }
1265 
MarkPoints(const Rectangle * pRect,sal_Bool bUnmark)1266 sal_Bool View::MarkPoints(const Rectangle* pRect, sal_Bool bUnmark)
1267 {
1268 	if( maSmartTags.MarkPoints( pRect, bUnmark ) )
1269 		return true;
1270 	else
1271 		return FmFormView::MarkPoints( pRect, bUnmark );
1272 }
1273 
CheckPossibilities()1274 void View::CheckPossibilities()
1275 {
1276 	FmFormView::CheckPossibilities();
1277 	maSmartTags.CheckPossibilities();
1278 }
1279 
OnBeginPasteOrDrop(PasteOrDropInfos *)1280 void View::OnBeginPasteOrDrop( PasteOrDropInfos* /*pInfos*/ )
1281 {
1282 }
1283 
1284 /** this is called after a paste or drop operation, make sure that the newly inserted paragraphs
1285 	get the correct style sheet. */
OnEndPasteOrDrop(PasteOrDropInfos * pInfos)1286 void View::OnEndPasteOrDrop( PasteOrDropInfos* pInfos )
1287 {
1288 	SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( GetTextEditObject() );
1289 	SdrOutliner* pOutliner = GetTextEditOutliner();
1290 	if( pOutliner && pTextObj && pTextObj->GetPage() )
1291 	{
1292 		SdPage* pPage = static_cast< SdPage* >( pTextObj->GetPage() );
1293 
1294 		SfxStyleSheet* pStyleSheet = 0;
1295 
1296 		const PresObjKind eKind = pPage->GetPresObjKind(pTextObj);
1297 		if( eKind != PRESOBJ_NONE )
1298 			pStyleSheet = pPage->GetStyleSheetForPresObj(eKind);
1299 		else
1300 			pStyleSheet = pTextObj->GetStyleSheet();
1301 
1302 		if( eKind == PRESOBJ_OUTLINE )
1303 		{
1304 			// for outline shapes, set the correct outline style sheet for each
1305 			// new paragraph, depending on the paragraph depth
1306 			SfxStyleSheetBasePool* pStylePool = GetDoc()->GetStyleSheetPool();
1307 
1308 			for ( sal_uInt32 nPara = pInfos->nStartPara; nPara <= pInfos->nEndPara; nPara++ )
1309 			{
1310 				sal_Int16 nDepth = pOutliner->GetDepth( nPara );
1311 
1312 				SfxStyleSheet* pStyle = 0;
1313 				if( nDepth > 0 )
1314 				{
1315 					String aStyleSheetName( pStyleSheet->GetName() );
1316 					aStyleSheetName.Erase( aStyleSheetName.Len() - 1, 1 );
1317 					aStyleSheetName += String::CreateFromInt32( nDepth );
1318 					pStyle = static_cast<SfxStyleSheet*>( pStylePool->Find( aStyleSheetName, pStyleSheet->GetFamily() ) );
1319 					DBG_ASSERT( pStyle, "sd::View::OnEndPasteOrDrop(), Style not found!" );
1320 				}
1321 
1322 				if( !pStyle )
1323 					pStyle = pStyleSheet;
1324 
1325 				pOutliner->SetStyleSheet( nPara, pStyle );
1326 			}
1327 		}
1328 		else
1329 		{
1330 			// just put the object style on each new paragraph
1331 			for ( sal_uInt16 nPara = pInfos->nStartPara; nPara <= pInfos->nEndPara; nPara++ )
1332 			{
1333 				pOutliner->SetStyleSheet( nPara, pStyleSheet );
1334 			}
1335 		}
1336 	}
1337 }
1338 
ShouldToggleOn(const bool bBulletOnOffMode,const bool bNormalBullet)1339 bool View::ShouldToggleOn(
1340     const bool bBulletOnOffMode,
1341     const bool bNormalBullet)
1342 {
1343 	// If setting bullets/numbering by the dialog, always should toggle on.
1344 	if (!bBulletOnOffMode)
1345 		return sal_True;
1346 	SdrModel* pSdrModel = GetModel();
1347 	if (!pSdrModel)
1348 		return sal_False;
1349 
1350 	sal_Bool bToggleOn = sal_False;
1351 	SdrOutliner* pOutliner = SdrMakeOutliner(OUTLINERMODE_TEXTOBJECT, pSdrModel);
1352 	sal_uInt32 nMarkCount = GetMarkedObjectCount();
1353 	for (sal_uInt32 nIndex = 0; nIndex < nMarkCount && !bToggleOn; nIndex++)
1354 	{
1355 		SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >(GetMarkedObjectByIndex(nIndex));
1356 		if (!pTextObj || pTextObj->IsTextEditActive())
1357 			continue;
1358 		if (pTextObj->ISA(SdrTableObj))
1359 		{
1360 			SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >(pTextObj);
1361 			if (!pTableObj)
1362 				continue;
1363 			CellPos aStart, aEnd;
1364 			SvxTableController* pTableController = dynamic_cast< SvxTableController* >(getSelectionController().get());
1365 			if (pTableController)
1366 			{
1367 				pTableController->getSelectedCells(aStart, aEnd);
1368 			}
1369 			else
1370 			{
1371 				aStart = pTableObj->getFirstCell();
1372 				aEnd = pTableObj->getLastCell();
1373 			}
1374 			sal_Int32 nColCount = pTableObj->getColumnCount();
1375 			for (sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow && !bToggleOn; nRow++)
1376 			{
1377 				for (sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol && !bToggleOn; nCol++)
1378 				{
1379 					sal_Int32 nIndex = nRow * nColCount + nCol;
1380 					SdrText* pText = pTableObj->getText(nIndex);
1381 					if (!pText || !pText->GetOutlinerParaObject())
1382 						continue;
1383 					pOutliner->SetText(*(pText->GetOutlinerParaObject()));
1384 					sal_Int16 nStatus = pOutliner->GetBulletsNumberingStatus();
1385 					bToggleOn = ((bNormalBullet && nStatus != 0) || (!bNormalBullet && nStatus != 1)) ? sal_True : bToggleOn;
1386 					pOutliner->Clear();
1387 				}
1388 			}
1389 		}
1390 		else
1391 		{
1392 			OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
1393 			if (!pParaObj)
1394 				continue;
1395 			pOutliner->SetText(*pParaObj);
1396 			sal_Int16 nStatus = pOutliner->GetBulletsNumberingStatus();
1397 			bToggleOn = ((bNormalBullet && nStatus != 0) || (!bNormalBullet && nStatus != 1)) ? sal_True : bToggleOn;
1398 			pOutliner->Clear();
1399 		}
1400 	}
1401 	delete pOutliner;
1402 	return bToggleOn;
1403 }
1404 
ChangeMarkedObjectsBulletsNumbering(const bool bToggle,const bool bHandleBullets,const SvxNumRule * pNumRule,const bool bSwitchOff)1405 void View::ChangeMarkedObjectsBulletsNumbering(
1406     const bool bToggle,
1407     const bool bHandleBullets,
1408     const SvxNumRule* pNumRule,
1409     const bool bSwitchOff )
1410 {
1411     SdrModel* pSdrModel = GetModel();
1412     Window* pWindow = dynamic_cast< Window* >(GetFirstOutputDevice());
1413     if (!pSdrModel || !pWindow)
1414         return;
1415 
1416     const bool bUndoEnabled = pSdrModel->IsUndoEnabled();
1417     SdrUndoGroup* pUndoGroup = bUndoEnabled ? new SdrUndoGroup(*pSdrModel) : 0;
1418 
1419     const bool bToggleOn =
1420         bSwitchOff
1421         ? false
1422         : ShouldToggleOn( bToggle, bHandleBullets );
1423 
1424     SdrOutliner* pOutliner = SdrMakeOutliner(OUTLINERMODE_TEXTOBJECT, pSdrModel);
1425     OutlinerView* pOutlinerView = new OutlinerView(pOutliner, pWindow);
1426 
1427     const sal_uInt32 nMarkCount = GetMarkedObjectCount();
1428 	for (sal_uInt32 nIndex = 0; nIndex < nMarkCount; nIndex++)
1429 	{
1430 		SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >(GetMarkedObjectByIndex(nIndex));
1431 		if (!pTextObj || pTextObj->IsTextEditActive())
1432 			continue;
1433 		if (pTextObj->ISA(SdrTableObj))
1434 		{
1435 			SdrTableObj* pTableObj = dynamic_cast< SdrTableObj* >(pTextObj);
1436 			if (!pTableObj)
1437 				continue;
1438 			CellPos aStart, aEnd;
1439 			SvxTableController* pTableController = dynamic_cast< SvxTableController* >(getSelectionController().get());
1440 			if (pTableController)
1441 			{
1442 				pTableController->getSelectedCells(aStart, aEnd);
1443 			}
1444 			else
1445 			{
1446 				aStart = pTableObj->getFirstCell();
1447 				aEnd = pTableObj->getLastCell();
1448 			}
1449 			sal_Int32 nColCount = pTableObj->getColumnCount();
1450 			for (sal_Int32 nRow = aStart.mnRow; nRow <= aEnd.mnRow; nRow++)
1451 			{
1452 				for (sal_Int32 nCol = aStart.mnCol; nCol <= aEnd.mnCol; nCol++)
1453 				{
1454 					sal_Int32 nIndex = nRow * nColCount + nCol;
1455 					SdrText* pText = pTableObj->getText(nIndex);
1456 					if (!pText || !pText->GetOutlinerParaObject())
1457 						continue;
1458 
1459 					pOutliner->SetText(*(pText->GetOutlinerParaObject()));
1460 					if (bUndoEnabled)
1461 					{
1462 						SdrUndoObjSetText* pTxtUndo = dynamic_cast< SdrUndoObjSetText* >(pSdrModel->GetSdrUndoFactory().CreateUndoObjectSetText(*pTextObj, nIndex));
1463 						pUndoGroup->AddAction(pTxtUndo);
1464 					}
1465                     if ( !bToggleOn )
1466                     {
1467                         pOutlinerView->SwitchOffBulletsNumbering();
1468                     }
1469                     else
1470                     {
1471                         pOutlinerView->ApplyBulletsNumbering( bHandleBullets, pNumRule, bToggle );
1472                     }
1473 					sal_uInt32 nParaCount = pOutliner->GetParagraphCount();
1474 					pText->SetOutlinerParaObject(pOutliner->CreateParaObject(0, nParaCount));
1475 					pOutliner->Clear();
1476 				}
1477 			}
1478 			// Broadcast the object change event.
1479 			if (!pTextObj->AdjustTextFrameWidthAndHeight())
1480 			{
1481 				pTextObj->SetChanged();
1482 				pTextObj->BroadcastObjectChange();
1483 			}
1484 		}
1485 		else
1486 		{
1487 			OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();
1488 			if (!pParaObj)
1489 				continue;
1490 			pOutliner->SetText(*pParaObj);
1491 			if (bUndoEnabled)
1492 			{
1493 				SdrUndoObjSetText* pTxtUndo = dynamic_cast< SdrUndoObjSetText* >(pSdrModel->GetSdrUndoFactory().CreateUndoObjectSetText(*pTextObj, 0));
1494 				pUndoGroup->AddAction(pTxtUndo);
1495 			}
1496             if ( !bToggleOn )
1497             {
1498                 pOutlinerView->SwitchOffBulletsNumbering();
1499             }
1500             else
1501             {
1502                 pOutlinerView->ApplyBulletsNumbering( bHandleBullets, pNumRule, bToggle );
1503             }
1504 			sal_uInt32 nParaCount = pOutliner->GetParagraphCount();
1505 			pTextObj->SetOutlinerParaObject(pOutliner->CreateParaObject(0, nParaCount));
1506 			pOutliner->Clear();
1507 		}
1508 	}
1509 
1510     if ( bUndoEnabled && pUndoGroup->GetActionCount() > 0 )
1511     {
1512         pSdrModel->BegUndo();
1513         pSdrModel->AddUndo(pUndoGroup);
1514         pSdrModel->EndUndo();
1515     }
1516 
1517     delete pOutliner;
1518     delete pOutlinerView;
1519 }
1520 
1521 } // end of namespace sd
1522