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