xref: /AOO41X/main/sd/source/ui/view/viewshe2.cxx (revision 35be51c2d4c577b31fc8e81493e6139a7d2796d5) 
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/beans/XPropertySet.hpp>
28 #include <com/sun/star/chart2/XChartDocument.hpp>
29 #include <com/sun/star/drawing/FillStyle.hpp>
30 #include <com/sun/star/drawing/LineStyle.hpp>
31 
32 #include "ViewShell.hxx"
33 #include "ViewShellHint.hxx"
34 
35 #include "ViewShellImplementation.hxx"
36 #include "FactoryIds.hxx"
37 
38 #ifndef _SVXIDS_HRC
39 #include <svx/svxids.hrc>
40 #endif
41 #ifndef _SCRBAR_HXX //autogen
42 #include <vcl/scrbar.hxx>
43 #endif
44 #include <svx/svdpagv.hxx>
45 #include <sfx2/dispatch.hxx>
46 #include <sfx2/app.hxx>
47 #include <svx/ruler.hxx>
48 #include <editeng/outliner.hxx>
49 #include <svtools/ehdl.hxx>
50 #include <svx/svdoole2.hxx>
51 #include <svtools/sfxecode.hxx>
52 #include <svx/fmshell.hxx>
53 #include <sfx2/dispatch.hxx>
54 #include <rtl/ustrbuf.hxx>
55 #include <unotools/moduleoptions.hxx>
56 #ifndef _SVX_DIALOGS_HRC
57 #include <svx/dialogs.hrc>
58 #endif
59 #include <sot/clsids.hxx>
60 
61 #include "misc.hxx"
62 #include "strings.hrc"
63 #include "app.hrc"
64 #include "unokywds.hxx"
65 
66 #include "sdundogr.hxx"
67 #include "FrameView.hxx"
68 #include "undopage.hxx"
69 #include "sdresid.hxx"
70 #include "drawdoc.hxx"
71 #include "View.hxx"
72 #include "fupoor.hxx"
73 #include "Client.hxx"
74 #include "DrawDocShell.hxx"
75 #include "fusearch.hxx"
76 #include "slideshow.hxx"
77 #include "sdpage.hxx"
78 #include "DrawViewShell.hxx"
79 #include "ViewShellBase.hxx"
80 
81 #include "Window.hxx"
82 
83 #include <sfx2/viewfrm.hxx>
84 #include <svtools/soerr.hxx>
85 #include <toolkit/helper/vclunohelper.hxx>
86 #include <svx/charthelper.hxx>
87 
88 #ifdef _MSC_VER
89 #pragma optimize ( "", off )
90 #endif
91 
92 using namespace com::sun::star;
93 
94 const String aEmptyStr;
95 
96 namespace sd {
97 
98 /*************************************************************************
99 |*
100 |* Scrollbar-Update: Thumbpos und VisibleSize anpassen
101 |*
102 \************************************************************************/
103 
104 void ViewShell::UpdateScrollBars()
105 {
106 	if (mpHorizontalScrollBar.get() != NULL)
107 	{
108 		long nW = (long)(mpContentWindow->GetVisibleWidth() * 32000);
109 		long nX = (long)(mpContentWindow->GetVisibleX() * 32000);
110 		mpHorizontalScrollBar->SetVisibleSize(nW);
111 		mpHorizontalScrollBar->SetThumbPos(nX);
112 		nW = 32000 - nW;
113 		long nLine = (long) (mpContentWindow->GetScrlLineWidth() * nW);
114 		long nPage = (long) (mpContentWindow->GetScrlPageWidth() * nW);
115 		mpHorizontalScrollBar->SetLineSize(nLine);
116 		mpHorizontalScrollBar->SetPageSize(nPage);
117 	}
118 
119 	if (mpVerticalScrollBar.get() != NULL)
120 	{
121 		long nH = (long)(mpContentWindow->GetVisibleHeight() * 32000);
122 		long nY = (long)(mpContentWindow->GetVisibleY() * 32000);
123 
124 		if(IsPageFlipMode()) // ie in zoom mode where no panning
125 		{
126 			SdPage* pPage = static_cast<DrawViewShell*>(this)->GetActualPage();
127 			sal_uInt16 nCurPage = (pPage->GetPageNum() - 1) / 2;
128 			sal_uInt16 nTotalPages = GetDoc()->GetSdPageCount(pPage->GetPageKind());
129 			mpVerticalScrollBar->SetRange(Range(0,256*nTotalPages));
130 			mpVerticalScrollBar->SetVisibleSize(256);
131 			mpVerticalScrollBar->SetThumbPos(256*nCurPage);
132 			mpVerticalScrollBar->SetLineSize(256);
133 			mpVerticalScrollBar->SetPageSize(256);
134 		}
135 		else
136 		{
137 			mpVerticalScrollBar->SetRange(Range(0,32000));
138 			mpVerticalScrollBar->SetVisibleSize(nH);
139 			mpVerticalScrollBar->SetThumbPos(nY);
140 			nH = 32000 - nH;
141 			long nLine = (long) (mpContentWindow->GetScrlLineHeight() * nH);
142 			long nPage = (long) (mpContentWindow->GetScrlPageHeight() * nH);
143 			mpVerticalScrollBar->SetLineSize(nLine);
144 			mpVerticalScrollBar->SetPageSize(nPage);
145 		}
146 	}
147 
148 	if (mbHasRulers)
149 	{
150 		UpdateHRuler();
151 		UpdateVRuler();
152 	}
153 
154 }
155 /*************************************************************************
156 |*
157 |* Handling fuer horizontale Scrollbars
158 |*
159 \************************************************************************/
160 
161 IMPL_LINK_INLINE_START(ViewShell, HScrollHdl, ScrollBar *, pHScroll )
162 {
163 	return VirtHScrollHdl(pHScroll);
164 }
165 IMPL_LINK_INLINE_END(ViewShell, HScrollHdl, ScrollBar *, pHScroll )
166 
167 /*************************************************************************
168 |*
169 |* virtueller Scroll-Handler fuer horizontale Scrollbars
170 |*
171 \************************************************************************/
172 
173 long ViewShell::VirtHScrollHdl(ScrollBar* pHScroll)
174 {
175 	long nDelta = pHScroll->GetDelta();
176 
177 	if (nDelta != 0)
178 	{
179 		double fX = (double) pHScroll->GetThumbPos() / pHScroll->GetRange().Len();
180 
181 		// alle Fenster der Spalte scrollen
182         ::sd::View* pView = GetView();
183         OutlinerView* pOLV = NULL;
184 
185         if (pView)
186             pOLV = pView->GetTextEditOutlinerView();
187 
188         if (pOLV)
189             pOLV->HideCursor();
190 
191         mpContentWindow->SetVisibleXY(fX, -1);
192 
193         Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT);
194         Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) );
195         aVisArea.SetPos(aVisAreaPos);
196         GetDocSh()->SetVisArea(aVisArea);
197 
198         Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
199         Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
200         VisAreaChanged(aVisAreaWin);
201 
202         if (pView)
203         {
204             pView->VisAreaChanged(GetActiveWindow());
205         }
206 
207         if (pOLV)
208             pOLV->ShowCursor();
209 
210 		if (mbHasRulers)
211 			UpdateHRuler();
212 
213 	}
214 
215 	return 0;
216 }
217 
218 /*************************************************************************
219 |*
220 |* Handling fuer vertikale Scrollbars
221 |*
222 \************************************************************************/
223 
224 IMPL_LINK_INLINE_START(ViewShell, VScrollHdl, ScrollBar *, pVScroll )
225 {
226 	return VirtVScrollHdl(pVScroll);
227 }
228 IMPL_LINK_INLINE_END(ViewShell, VScrollHdl, ScrollBar *, pVScroll )
229 
230 /*************************************************************************
231 |*
232 |* Handling fuer vertikale Scrollbars
233 |*
234 \************************************************************************/
235 
236 long ViewShell::VirtVScrollHdl(ScrollBar* pVScroll)
237 {
238 	if(IsPageFlipMode())
239 	{
240 		SdPage* pPage = static_cast<DrawViewShell*>(this)->GetActualPage();
241 		sal_uInt16 nCurPage = (pPage->GetPageNum() - 1) >> 1;
242 		sal_uInt16 nNewPage = (sal_uInt16)pVScroll->GetThumbPos()/256;
243 		if( nCurPage != nNewPage )
244 			static_cast<DrawViewShell*>(this)->SwitchPage(nNewPage);
245 	}
246 	else //panning mode
247 	{
248 		double fY = (double) pVScroll->GetThumbPos() / pVScroll->GetRange().Len();
249 
250         ::sd::View* pView = GetView();
251         OutlinerView* pOLV = NULL;
252 
253         if (pView)
254             pOLV = pView->GetTextEditOutlinerView();
255 
256         if (pOLV)
257             pOLV->HideCursor();
258 
259         mpContentWindow->SetVisibleXY(-1, fY);
260 
261         Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT);
262         Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) );
263         aVisArea.SetPos(aVisAreaPos);
264         GetDocSh()->SetVisArea(aVisArea);
265 
266         Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
267         Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
268         VisAreaChanged(aVisAreaWin);
269 
270         if (pView)
271         {
272             pView->VisAreaChanged(GetActiveWindow());
273         }
274 
275         if (pOLV)
276             pOLV->ShowCursor();
277 
278 		if (mbHasRulers)
279 			UpdateVRuler();
280 
281 	}
282 
283 	return 0;
284 }
285 
286 SvxRuler* ViewShell::CreateHRuler(::sd::Window* , sal_Bool )
287 {
288 	return NULL;
289 }
290 
291 SvxRuler* ViewShell::CreateVRuler(::sd::Window* )
292 {
293 	return NULL;
294 }
295 
296 void ViewShell::UpdateHRuler()
297 {
298 }
299 
300 void ViewShell::UpdateVRuler()
301 {
302 }
303 
304 long ViewShell::GetHCtrlWidth()
305 {
306 	return 0;
307 }
308 
309 /*************************************************************************
310 |*
311 |* Eine bestimmte Anzahl von Zeilen scrollen (wird beim automatischen
312 |* Scrollen (Zeichen/Draggen) verwendet)
313 |*
314 \************************************************************************/
315 
316 void ViewShell::ScrollLines(long nLinesX, long nLinesY)
317 {
318 	if ( nLinesX )
319 	{
320 		nLinesX *= mpHorizontalScrollBar->GetLineSize();
321 	}
322 	if ( nLinesY )
323 	{
324 		nLinesY *= mpVerticalScrollBar->GetLineSize();
325 	}
326 
327 	Scroll(nLinesX, nLinesY);
328 }
329 
330 /*************************************************************************
331 |*
332 |* Window um nScrollX, nScrollY scrollen
333 |*
334 \************************************************************************/
335 
336 void ViewShell::Scroll(long nScrollX, long nScrollY)
337 {
338 	if (nScrollX)
339 	{
340 		long nNewThumb = mpHorizontalScrollBar->GetThumbPos() + nScrollX;
341 		mpHorizontalScrollBar->SetThumbPos(nNewThumb);
342 	}
343 	if (nScrollY)
344 	{
345 		long nNewThumb = mpVerticalScrollBar->GetThumbPos() + nScrollY;
346 		mpVerticalScrollBar->SetThumbPos(nNewThumb);
347 	}
348 	double	fX = (double) mpHorizontalScrollBar->GetThumbPos() /
349 							mpHorizontalScrollBar->GetRange().Len();
350 	double	fY = (double) mpVerticalScrollBar->GetThumbPos() /
351 							mpVerticalScrollBar->GetRange().Len();
352 
353 	GetActiveWindow()->SetVisibleXY(fX, fY);
354 
355 	Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT);
356 	Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) );
357 	aVisArea.SetPos(aVisAreaPos);
358 	GetDocSh()->SetVisArea(aVisArea);
359 
360 	Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
361 	Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
362 	VisAreaChanged(aVisAreaWin);
363 
364 	::sd::View* pView = GetView();
365 	if (pView)
366 	{
367 		pView->VisAreaChanged(GetActiveWindow());
368 	}
369 
370 	if (mbHasRulers)
371 	{
372 		UpdateHRuler();
373 		UpdateVRuler();
374 	}
375 }
376 
377 /*************************************************************************
378 |*
379 |* Den Zoomfaktor fuer alle Split-Windows setzen
380 |*
381 \************************************************************************/
382 
383 void ViewShell::SetZoom(long nZoom)
384 {
385 	Fraction aUIScale(nZoom, 100);
386 	aUIScale *= GetDoc()->GetUIScale();
387 
388     if (mpHorizontalRuler.get() != NULL)
389         mpHorizontalRuler->SetZoom(aUIScale);
390 
391     if (mpVerticalRuler.get() != NULL)
392         mpVerticalRuler->SetZoom(aUIScale);
393 
394     if (mpContentWindow.get() != NULL)
395     {
396         mpContentWindow->SetZoomIntegral(nZoom);
397 
398 		// #i74769# Here is a 2nd way (besides Window::Scroll) to set the visible prt
399 		// of the window. It needs - like Scroll(SCROLL_CHILDREN) does - also to move
400 		// the child windows. I am trying INVALIDATE_CHILDREN here which makes things better,
401 		// but does not solve the problem completely. Neet to ask PL.
402         mpContentWindow->Invalidate(INVALIDATE_CHILDREN);
403     }
404 
405 	Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
406 	Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
407 	VisAreaChanged(aVisAreaWin);
408 
409 	::sd::View* pView = GetView();
410 	if (pView)
411 	{
412 		pView->VisAreaChanged(GetActiveWindow());
413 	}
414 
415 	UpdateScrollBars();
416 }
417 
418 /*************************************************************************
419 |*
420 |* Zoomrechteck fuer aktives Fenster einstellen und alle Split-Windows
421 |* auf den gleichen Zoomfaktor setzen
422 |*
423 \************************************************************************/
424 
425 void ViewShell::SetZoomRect(const Rectangle& rZoomRect)
426 {
427 	long nZoom = GetActiveWindow()->SetZoomRect(rZoomRect);
428 	Fraction aUIScale(nZoom, 100);
429 	aUIScale *= GetDoc()->GetUIScale();
430 
431 	Point aPos = GetActiveWindow()->GetWinViewPos();
432 
433     if (mpHorizontalRuler.get() != NULL)
434         mpHorizontalRuler->SetZoom(aUIScale);
435 
436     if (mpVerticalRuler.get() != NULL)
437         mpVerticalRuler->SetZoom(aUIScale);
438 
439     if (mpContentWindow.get() != NULL)
440     {
441         Point aNewPos = mpContentWindow->GetWinViewPos();
442         aNewPos.X() = aPos.X();
443         aNewPos.Y() = aPos.Y();
444         mpContentWindow->SetZoomIntegral(nZoom);
445         mpContentWindow->SetWinViewPos(aNewPos);
446         mpContentWindow->UpdateMapOrigin();
447 
448 		// #i74769# see above
449         mpContentWindow->Invalidate(INVALIDATE_CHILDREN);
450     }
451 
452 	Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
453 	Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
454 	VisAreaChanged(aVisAreaWin);
455 
456 	::sd::View* pView = GetView();
457 	if (pView)
458 	{
459 		pView->VisAreaChanged(GetActiveWindow());
460 	}
461 
462 	UpdateScrollBars();
463 }
464 
465 /*************************************************************************
466 |*
467 |* Abbildungsparameter fuer alle Split-Windows initialisieren
468 |*
469 \************************************************************************/
470 
471 void ViewShell::InitWindows(const Point& rViewOrigin, const Size& rViewSize,
472 							  const Point& rWinPos, sal_Bool bUpdate)
473 {
474     if (mpContentWindow.get() != NULL)
475     {
476         mpContentWindow->SetViewOrigin(rViewOrigin);
477         mpContentWindow->SetViewSize(rViewSize);
478         mpContentWindow->SetWinViewPos(rWinPos);
479 
480         if ( bUpdate )
481         {
482             mpContentWindow->UpdateMapOrigin();
483             mpContentWindow->Invalidate();
484         }
485     }
486 
487 	Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
488 	Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
489 	VisAreaChanged(aVisAreaWin);
490 
491 	::sd::View* pView = GetView();
492 	if (pView)
493 	{
494 		pView->VisAreaChanged(GetActiveWindow());
495 	}
496 }
497 
498 /*************************************************************************
499 |*
500 |* Alle Split-Windows unter dem uebergebenen Rechteck invalidieren
501 |*
502 \************************************************************************/
503 
504 void ViewShell::InvalidateWindows()
505 {
506     if (mpContentWindow.get() != NULL)
507         mpContentWindow->Invalidate();
508 }
509 
510 
511 /*************************************************************************
512 |*
513 |* Auf allen Split-Windows ein Markierungsrechteck mit dem
514 |* uebergebenen Pen zeichnen
515 |*
516 \************************************************************************/
517 
518 void ViewShell::DrawMarkRect(const Rectangle& rRect) const
519 {
520     if (mpContentWindow.get() != NULL)
521     {
522         mpContentWindow->InvertTracking(rRect, SHOWTRACK_OBJECT | SHOWTRACK_WINDOW);
523     }
524 }
525 
526 /*************************************************************************
527 |*
528 |* Groesse und Raender aller Seiten setzen
529 |*
530 \************************************************************************/
531 
532 void ViewShell::SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize,
533 									   long nLeft, long nRight,
534 									   long nUpper, long nLower, sal_Bool bScaleAll,
535 									   Orientation eOrientation, sal_uInt16 nPaperBin,
536 							           sal_Bool bBackgroundFullSize)
537 {
538 	SdPage* pPage = 0;
539 	SdUndoGroup* pUndoGroup = NULL;
540 	pUndoGroup = new SdUndoGroup(GetDoc());
541 	String aString(SdResId(STR_UNDO_CHANGE_PAGEFORMAT));
542 	pUndoGroup->SetComment(aString);
543     SfxViewShell* pViewShell = GetViewShell();
544     OSL_ASSERT (pViewShell!=NULL);
545 
546 	sal_uInt16 i, nPageCnt = GetDoc()->GetMasterSdPageCount(ePageKind);
547 
548     Broadcast (ViewShellHint(ViewShellHint::HINT_PAGE_RESIZE_START));
549 
550 	for (i = 0; i < nPageCnt; i++)
551 	{
552 		/**********************************************************************
553 		* Erst alle MasterPages bearbeiten
554 		**********************************************************************/
555 		pPage = GetDoc()->GetMasterSdPage(i, ePageKind);
556 
557 		SdUndoAction* pUndo = new SdPageFormatUndoAction(GetDoc(), pPage,
558 							pPage->GetSize(),
559 							pPage->GetLftBorder(), pPage->GetRgtBorder(),
560 							pPage->GetUppBorder(), pPage->GetLwrBorder(),
561 							pPage->IsScaleObjects(),
562 							pPage->GetOrientation(),
563 							pPage->GetPaperBin(),
564 							pPage->IsBackgroundFullSize(),
565 							rNewSize,
566 							nLeft, nRight,
567 							nUpper, nLower,
568 							bScaleAll,
569 							eOrientation,
570 							nPaperBin,
571 							bBackgroundFullSize);
572 		pUndoGroup->AddAction(pUndo);
573 
574 		if (rNewSize.Width() > 0 ||
575 			nLeft  >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0)
576 		{
577 			Rectangle aNewBorderRect(nLeft, nUpper, nRight, nLower);
578 			pPage->ScaleObjects(rNewSize, aNewBorderRect, bScaleAll);
579 
580 			if (rNewSize.Width() > 0)
581 				pPage->SetSize(rNewSize);
582 		}
583 
584 		if( nLeft  >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0 )
585 		{
586 			pPage->SetBorder(nLeft, nUpper, nRight, nLower);
587 		}
588 
589 		pPage->SetOrientation(eOrientation);
590 		pPage->SetPaperBin( nPaperBin );
591 		pPage->SetBackgroundFullSize( bBackgroundFullSize );
592 
593 		if ( ePageKind == PK_STANDARD )
594 			GetDoc()->GetMasterSdPage(i, PK_NOTES)->CreateTitleAndLayout();
595 
596 		pPage->CreateTitleAndLayout();
597 	}
598 
599 	nPageCnt = GetDoc()->GetSdPageCount(ePageKind);
600 
601 	for (i = 0; i < nPageCnt; i++)
602 	{
603 		/**********************************************************************
604 		* Danach alle Pages bearbeiten
605 		**********************************************************************/
606 		pPage = GetDoc()->GetSdPage(i, ePageKind);
607 
608 		SdUndoAction* pUndo = new SdPageFormatUndoAction(GetDoc(), pPage,
609 								pPage->GetSize(),
610 								pPage->GetLftBorder(), pPage->GetRgtBorder(),
611 								pPage->GetUppBorder(), pPage->GetLwrBorder(),
612 								pPage->IsScaleObjects(),
613 								pPage->GetOrientation(),
614 								pPage->GetPaperBin(),
615 								pPage->IsBackgroundFullSize(),
616 								rNewSize,
617 								nLeft, nRight,
618 								nUpper, nLower,
619 								bScaleAll,
620 								eOrientation,
621 								nPaperBin,
622 								bBackgroundFullSize);
623 		pUndoGroup->AddAction(pUndo);
624 
625 		if (rNewSize.Width() > 0 ||
626 			nLeft  >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0)
627 		{
628 			Rectangle aNewBorderRect(nLeft, nUpper, nRight, nLower);
629 			pPage->ScaleObjects(rNewSize, aNewBorderRect, bScaleAll);
630 
631 			if (rNewSize.Width() > 0)
632 				pPage->SetSize(rNewSize);
633 		}
634 
635 		if( nLeft  >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0 )
636 		{
637 			pPage->SetBorder(nLeft, nUpper, nRight, nLower);
638 		}
639 
640 		pPage->SetOrientation(eOrientation);
641 		pPage->SetPaperBin( nPaperBin );
642 		pPage->SetBackgroundFullSize( bBackgroundFullSize );
643 
644 		if ( ePageKind == PK_STANDARD )
645 		{
646 			SdPage* pNotesPage = GetDoc()->GetSdPage(i, PK_NOTES);
647 			pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() );
648 		}
649 
650 		pPage->SetAutoLayout( pPage->GetAutoLayout() );
651 	}
652 
653 	// Handoutseite an neues Format der Standardseiten anpassen
654 	if( (ePageKind == PK_STANDARD) || (ePageKind == PK_HANDOUT) )
655 		GetDoc()->GetSdPage(0, PK_HANDOUT)->CreateTitleAndLayout(sal_True);
656 
657 	// Undo Gruppe dem Undo Manager uebergeben
658 	pViewShell->GetViewFrame()->GetObjectShell()
659         ->GetUndoManager()->AddUndoAction(pUndoGroup);
660 
661 	long nWidth = pPage->GetSize().Width();
662 	long nHeight = pPage->GetSize().Height();
663 
664 	Point aPageOrg = Point(nWidth, nHeight / 2);
665 	Size aViewSize = Size(nWidth * 3, nHeight * 2);
666 
667 	InitWindows(aPageOrg, aViewSize, Point(-1, -1), sal_True);
668 
669 	Point aVisAreaPos;
670 
671 	if ( GetDocSh()->GetCreateMode() == SFX_CREATE_MODE_EMBEDDED )
672 	{
673 		aVisAreaPos = GetDocSh()->GetVisArea(ASPECT_CONTENT).TopLeft();
674 	}
675 
676 	::sd::View* pView = GetView();
677 	if (pView)
678 	{
679 		pView->SetWorkArea(Rectangle(Point() - aVisAreaPos - aPageOrg, aViewSize));
680 	}
681 
682 	UpdateScrollBars();
683 
684 	Point aNewOrigin(pPage->GetLftBorder(), pPage->GetUppBorder());
685 
686 	if (pView)
687 	{
688 		pView->GetSdrPageView()->SetPageOrigin(aNewOrigin);
689 	}
690 
691 	pViewShell->GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET);
692 
693 	// auf (neue) Seitengroesse zoomen
694 	pViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_PAGE,
695 			SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
696 
697     Broadcast (ViewShellHint(ViewShellHint::HINT_PAGE_RESIZE_END));
698 }
699 
700 /*************************************************************************
701 |*
702 |* Zoom-Faktor fuer InPlace einstellen
703 |*
704 \************************************************************************/
705 
706 void ViewShell::SetZoomFactor(const Fraction& rZoomX, const Fraction&)
707 {
708 	long nZoom = (long)((double) rZoomX * 100);
709 	SetZoom(nZoom);
710 }
711 
712 
713 /*************************************************************************
714 |*
715 |* Aktives Fenster setzen
716 |*
717 \************************************************************************/
718 
719 void ViewShell::SetActiveWindow (::sd::Window* pWin)
720 {
721     SfxViewShell* pViewShell = GetViewShell();
722     OSL_ASSERT (pViewShell!=NULL);
723 
724     if (pViewShell->GetWindow() != pWin)
725 	{
726 		// #i31551# was wrong, it may have been a problem with the repaint at that time.
727 		// For transparent form controls, it is necessary to have that flag set, all apps
728 		// do set it. Enabling again.
729 		if (pWin)
730 		{
731 			pWin->EnableChildTransparentMode();
732 		}
733 	}
734 
735     if (mpActiveWindow != pWin)
736         mpActiveWindow = pWin;
737 
738     // The rest of this function is not guarded anymore against calling this
739     // method with an already active window because the functions may still
740     // point to the old window when the new one has already been assigned to
741     // pWindow elsewhere.
742     ::sd::View* pView = GetView();
743     if (pView)
744     {
745         pView->SetActualWin(pWin);
746     }
747     if(HasCurrentFunction())
748     {
749         GetCurrentFunction()->SetWindow(pWin);
750     }
751 }
752 
753 
754 
755 /*************************************************************************
756 |*
757 |* RequestHelp event
758 |*
759 \************************************************************************/
760 
761 sal_Bool ViewShell::RequestHelp(const HelpEvent& rHEvt, ::sd::Window*)
762 {
763 	sal_Bool bReturn = sal_False;
764 
765 	if (rHEvt.GetMode())
766 	{
767 		if( GetView() )
768 			bReturn = GetView()->getSmartTags().RequestHelp(rHEvt);
769 
770 		if(!bReturn && HasCurrentFunction())
771 		{
772 			bReturn = GetCurrentFunction()->RequestHelp(rHEvt);
773 		}
774 	}
775 
776 	return(bReturn);
777 }
778 
779 
780 
781 
782 FrameView* ViewShell::GetFrameView (void)
783 {
784     return mpFrameView;
785 }
786 
787 
788 
789 
790 void ViewShell::SetFrameView (FrameView* pNewFrameView)
791 {
792     mpFrameView = pNewFrameView;
793     ReadFrameViewData (mpFrameView);
794 }
795 
796 
797 
798 
799 /*************************************************************************
800 |*
801 |* Read FrameViews data and set actual views data
802 |*
803 \************************************************************************/
804 
805 void ViewShell::ReadFrameViewData(FrameView*)
806 {
807 }
808 
809 
810 
811 /*************************************************************************
812 |*
813 |* Write actual views data to FrameView
814 |*
815 \************************************************************************/
816 
817 void ViewShell::WriteFrameViewData()
818 {
819 }
820 
821 /*************************************************************************
822 |*
823 |* OLE-Object aktivieren
824 |*
825 \************************************************************************/
826 
827 sal_Bool ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
828 {
829 	ErrCode aErrCode = 0;
830 
831 	SfxErrorContext aEC(ERRCTX_SO_DOVERB, GetActiveWindow(), RID_SO_ERRCTX);
832 	sal_Bool bAbort = sal_False;
833 	GetDocSh()->SetWaitCursor( sal_True );
834     SfxViewShell* pViewShell = GetViewShell();
835     OSL_ASSERT (pViewShell!=NULL);
836     bool bChangeDefaultsForChart = false;
837 
838     uno::Reference < embed::XEmbeddedObject > xObj = pObj->GetObjRef();
839     if ( !xObj.is() )
840 	{
841 		/**********************************************************
842 		* Leeres OLE-Objekt mit OLE-Objekt versehen
843 		**********************************************************/
844 		String aName = pObj->GetProgName();
845         ::rtl::OUString aObjName;
846         SvGlobalName aClass;
847 
848         if( aName.EqualsAscii( "StarChart" ) || aName.EqualsAscii("StarOrg") )
849 		{
850 			if( SvtModuleOptions().IsChart() )
851             {
852                 aClass = SvGlobalName( SO3_SCH_CLASSID );
853                 bChangeDefaultsForChart = true;
854             }
855 		}
856 		else if( aName.EqualsAscii( "StarCalc" ))
857 		{
858 			if( SvtModuleOptions().IsCalc() )
859                 aClass = SvGlobalName( SO3_SC_CLASSID );
860 		}
861 		else if( aName.EqualsAscii( "StarMath" ))
862 		{
863 			if( SvtModuleOptions().IsMath() )
864                 aClass = SvGlobalName( SO3_SM_CLASSID );
865 		}
866 
867         if ( aClass != SvGlobalName() )
868             xObj = GetDocSh()->GetEmbeddedObjectContainer().CreateEmbeddedObject( aClass.GetByteSequence(), aObjName );
869 
870         if( !xObj.is() )
871 		{
872 			aName = String();
873 
874 			// Dialog "OLE-Objekt einfuegen" aufrufen
875 			GetDocSh()->SetWaitCursor( sal_False );
876 			pViewShell->GetViewFrame()->GetDispatcher()->Execute(
877                 SID_INSERT_OBJECT,
878                 SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD);
879             xObj = pObj->GetObjRef();
880 			GetDocSh()->SetWaitCursor( sal_True );
881 
882             if (!xObj.is())
883 			{
884 				bAbort = sal_True;
885 			}
886 		}
887 
888         if ( xObj.is() )
889 		{
890 			/******************************************************
891 			* OLE-Objekt ist nicht mehr leer
892 			******************************************************/
893 			pObj->SetEmptyPresObj(sal_False);
894 			pObj->SetOutlinerParaObject(NULL);
895 			pObj->SetGraphic(NULL);
896 
897 			/******************************************************
898 			* Das leere OLE-Objekt bekommt ein neues IPObj
899 			******************************************************/
900 			if (aName.Len())
901 			{
902                 pObj->SetObjRef(xObj);
903 				pObj->SetName(aObjName);
904     			pObj->SetPersistName(aObjName);
905 			}
906 			else
907 			{
908 				// Das Einfuegen hat der Dialog schon gemacht
909                 pObj->SetObjRef(xObj);
910 			}
911 
912 			Rectangle aRect = pObj->GetLogicRect();
913 
914 			if ( pObj->GetAspect() != embed::Aspects::MSOLE_ICON )
915 			{
916             	awt::Size aSz;
917             	aSz.Width = aRect.GetWidth();
918             	aSz.Height = aRect.GetHeight();
919             	xObj->setVisualAreaSize( pObj->GetAspect(), aSz );
920 			}
921 
922             GetViewShellBase().SetVerbs( xObj->getSupportedVerbs() );
923 
924 			nVerb = SVVERB_SHOW;
925 		}
926 		else
927 		{
928 			aErrCode = ERRCODE_SFX_OLEGENERAL;
929 		}
930 	}
931 
932 	if( aErrCode == 0 )
933 	{
934 		::sd::View* pView = GetView();
935 
936 		if (pView->IsTextEdit())
937 		{
938 			pView->SdrEndTextEdit();
939 		}
940 
941         SfxInPlaceClient* pSdClient =
942             static_cast<Client*>(pViewShell->FindIPClient(
943                 pObj->GetObjRef(), GetActiveWindow()));
944 
945         if ( !pSdClient )
946 		{
947 			pSdClient = new Client(pObj, this, GetActiveWindow());
948 		}
949 
950 		Rectangle aRect = pObj->GetLogicRect();
951 
952         {
953             // #i118485# center on BoundRect for activation,
954             // OLE may be sheared/rotated now
955         	const Rectangle& rBoundRect = pObj->GetCurrentBoundRect();
956             const Point aDelta(rBoundRect.Center() - aRect.Center());
957             aRect.Move(aDelta.X(), aDelta.Y());
958         }
959 
960         Size aDrawSize = aRect.GetSize();
961 
962 		MapMode aMapMode( GetDoc()->GetScaleUnit() );
963         Size aObjAreaSize = pObj->GetOrigObjSize( &aMapMode );
964         if( pObj->IsChart() ) //charts never should be stretched see #i84323# for example
965             aObjAreaSize = aDrawSize;
966 
967         Fraction aScaleWidth (aDrawSize.Width(),  aObjAreaSize.Width() );
968         Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() );
969         aScaleWidth.ReduceInaccurate(10);       // kompatibel zum SdrOle2Obj
970         aScaleHeight.ReduceInaccurate(10);
971         pSdClient->SetSizeScale(aScaleWidth, aScaleHeight);
972 
973         // sichtbarer Ausschnitt wird nur inplace veraendert!
974         aRect.SetSize(aObjAreaSize);
975 		// the object area size must be set after scaling, since it triggers the resizing
976         pSdClient->SetObjArea(aRect);
977 
978         if( bChangeDefaultsForChart && xObj.is())
979         {
980             ChartHelper::AdaptDefaultsForChart( xObj );
981         }
982 
983         pSdClient->DoVerb(nVerb);   // ErrCode wird ggf. vom Sfx ausgegeben
984 		pViewShell->GetViewFrame()->GetBindings().Invalidate(
985             SID_NAVIGATOR_STATE, sal_True, sal_False);
986 	}
987 
988 	GetDocSh()->SetWaitCursor( sal_False );
989 
990 	if (aErrCode != 0 && !bAbort)
991 	{
992 		ErrorHandler::HandleError(* new StringErrorInfo(aErrCode, String() ) );
993 	}
994 
995 	return aErrCode == 0;
996 }
997 
998 /*************************************************************************
999 |*
1000 |* umschliessendes Rechteck aller (Split-)Fenster zurueckgeben.
1001 |*
1002 \************************************************************************/
1003 
1004 const Rectangle& ViewShell::GetAllWindowRect()
1005 {
1006 	maAllWindowRectangle.SetPos(
1007         mpContentWindow->OutputToScreenPixel(Point(0,0)));
1008 	return maAllWindowRectangle;
1009 }
1010 
1011 /*************************************************************************
1012 |*
1013 |* Read user data
1014 |*
1015 \************************************************************************/
1016 void ViewShell::ReadUserData(const String&)
1017 {
1018 	// Auf an FrameView gemerkte VisArea zoomen
1019 	GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_VISAREA,
1020         SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
1021 }
1022 
1023 /*************************************************************************
1024 |*
1025 |* Write user data
1026 |*
1027 \************************************************************************/
1028 
1029 void ViewShell::WriteUserData(String&)
1030 {
1031 	// Das Schreiben unserer Daten erfolgt stets in WriteFrameViewData()
1032 	WriteFrameViewData();
1033 }
1034 
1035 
1036 /*************************************************************************
1037 |*
1038 |* Lineale ein- / ausschalten
1039 |*
1040 \************************************************************************/
1041 
1042 void ViewShell::SetRuler(sal_Bool bRuler)
1043 {
1044     mbHasRulers = ( bRuler && !GetDocSh()->IsPreview() ); // no rulers on preview mode
1045 
1046     if (mpHorizontalRuler.get() != NULL)
1047     {
1048         if (mbHasRulers)
1049         {
1050             mpHorizontalRuler->Show();
1051         }
1052         else
1053         {
1054             mpHorizontalRuler->Hide();
1055         }
1056     }
1057 
1058     if (mpVerticalRuler.get() != NULL)
1059     {
1060         if (mbHasRulers)
1061         {
1062             mpVerticalRuler->Show();
1063         }
1064         else
1065         {
1066             mpVerticalRuler->Hide();
1067         }
1068     }
1069 
1070     OSL_ASSERT(GetViewShell()!=NULL);
1071     if (IsMainViewShell())
1072         GetViewShell()->InvalidateBorder();
1073 }
1074 
1075 /*************************************************************************
1076 |*
1077 |* AcceptDrop
1078 |*
1079 \************************************************************************/
1080 
1081 sal_Int8 ViewShell::AcceptDrop (
1082     const AcceptDropEvent& rEvt,
1083     DropTargetHelper& rTargetHelper,
1084     ::sd::Window* pTargetWindow,
1085     sal_uInt16 nPage,
1086     sal_uInt16 nLayer)
1087 {
1088 	::sd::View* pView = GetView();
1089 	return( pView ? pView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE );
1090 }
1091 
1092 /*************************************************************************
1093 |*
1094 |* ExecuteDrop
1095 |*
1096 \************************************************************************/
1097 
1098 sal_Int8 ViewShell::ExecuteDrop (
1099     const ExecuteDropEvent& rEvt,
1100     DropTargetHelper& rTargetHelper,
1101     ::sd::Window* pTargetWindow,
1102     sal_uInt16 nPage,
1103     sal_uInt16 nLayer)
1104 {
1105 	::sd::View*	pView = GetView();
1106 	return( pView ? pView->ExecuteDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE );
1107 }
1108 
1109 #ifdef _MSC_VER
1110 #pragma optimize ( "", on )
1111 #endif
1112 
1113 void ViewShell::WriteUserDataSequence ( ::com::sun::star::uno::Sequence <
1114     ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse)
1115 {
1116 	const sal_Int32 nIndex = rSequence.getLength();
1117 	rSequence.realloc( nIndex + 1 );
1118 
1119     OSL_ASSERT (GetViewShell()!=NULL);
1120     // Get the view id from the view shell in the center pane.  This will
1121     // usually be the called view shell, but to be on the safe side we call
1122     // the main view shell explicitly.
1123     sal_uInt16 nViewID (IMPRESS_FACTORY_ID);
1124     if (GetViewShellBase().GetMainViewShell().get() != NULL)
1125         nViewID = GetViewShellBase().GetMainViewShell()->mpImpl->GetViewId();
1126 	rSequence[nIndex].Name = rtl::OUString (
1127         RTL_CONSTASCII_USTRINGPARAM( sUNO_View_ViewId ) );
1128 	rtl::OUStringBuffer sBuffer (
1129         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "view" ) ) );
1130 	sBuffer.append( static_cast<sal_Int32>(nViewID));
1131 	rSequence[nIndex].Value <<= sBuffer.makeStringAndClear();
1132 
1133 	mpFrameView->WriteUserDataSequence( rSequence, bBrowse );
1134 }
1135 
1136 
1137 void ViewShell::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse )
1138 {
1139 	mpFrameView->ReadUserDataSequence( rSequence, bBrowse );
1140 }
1141 
1142 void ViewShell::VisAreaChanged(const Rectangle& rRect)
1143 {
1144     OSL_ASSERT (GetViewShell()!=NULL);
1145 	GetViewShell()->VisAreaChanged(rRect);
1146 }
1147 
1148 void ViewShell::SetWinViewPos(const Point& rWinPos, bool bUpdate)
1149 {
1150     if (mpContentWindow.get() != NULL)
1151     {
1152         mpContentWindow->SetWinViewPos(rWinPos);
1153 
1154         if ( bUpdate )
1155         {
1156             mpContentWindow->UpdateMapOrigin();
1157             mpContentWindow->Invalidate();
1158         }
1159     }
1160 
1161 	if (mbHasRulers)
1162 	{
1163 		UpdateHRuler();
1164 		UpdateVRuler();
1165 	}
1166 
1167 	UpdateScrollBars();
1168 
1169 	Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
1170 	Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
1171 	VisAreaChanged(aVisAreaWin);
1172 
1173 	::sd::View* pView = GetView();
1174 	if (pView)
1175 	{
1176 		pView->VisAreaChanged(GetActiveWindow());
1177 	}
1178 }
1179 
1180 Point ViewShell::GetWinViewPos() const
1181 {
1182 	return mpContentWindow->GetWinViewPos();
1183 }
1184 
1185 Point ViewShell::GetViewOrigin() const
1186 {
1187 	return mpContentWindow->GetViewOrigin();
1188 }
1189 
1190 } // end of namespace sd
1191