xref: /trunk/main/sd/source/ui/view/viewshe2.cxx (revision 1ecadb572e7010ff3b3382ad9bf179dbc6efadbb) 
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         Size aDrawSize = aRect.GetSize();
955 
956         MapMode aMapMode( GetDoc()->GetScaleUnit() );
957         Size aObjAreaSize = pObj->GetOrigObjSize( &aMapMode );
958         if( pObj->IsChart() ) //charts never should be stretched see #i84323# for example
959             aObjAreaSize = aDrawSize;
960 
961         Fraction aScaleWidth (aDrawSize.Width(),  aObjAreaSize.Width() );
962         Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() );
963         aScaleWidth.ReduceInaccurate(10);       // kompatibel zum SdrOle2Obj
964         aScaleHeight.ReduceInaccurate(10);
965         pSdClient->SetSizeScale(aScaleWidth, aScaleHeight);
966 
967         // sichtbarer Ausschnitt wird nur inplace veraendert!
968         aRect.SetSize(aObjAreaSize);
969         // the object area size must be set after scaling, since it triggers the resizing
970         pSdClient->SetObjArea(aRect);
971 
972         if( bChangeDefaultsForChart && xObj.is())
973         {
974             AdaptDefaultsForChart( xObj );
975         }
976 
977         pSdClient->DoVerb(nVerb);   // ErrCode wird ggf. vom Sfx ausgegeben
978         pViewShell->GetViewFrame()->GetBindings().Invalidate(
979             SID_NAVIGATOR_STATE, sal_True, sal_False);
980     }
981 
982     GetDocSh()->SetWaitCursor( sal_False );
983 
984     if (aErrCode != 0 && !bAbort)
985     {
986         ErrorHandler::HandleError(* new StringErrorInfo(aErrCode, String() ) );
987     }
988 
989     return aErrCode == 0;
990 }
991 
992 /*************************************************************************
993 |*
994 |* umschliessendes Rechteck aller (Split-)Fenster zurueckgeben.
995 |*
996 \************************************************************************/
997 
998 const Rectangle& ViewShell::GetAllWindowRect()
999 {
1000     maAllWindowRectangle.SetPos(
1001         mpContentWindow->OutputToScreenPixel(Point(0,0)));
1002     return maAllWindowRectangle;
1003 }
1004 
1005 /*************************************************************************
1006 |*
1007 |* Read user data
1008 |*
1009 \************************************************************************/
1010 void ViewShell::ReadUserData(const String&)
1011 {
1012     // Auf an FrameView gemerkte VisArea zoomen
1013     GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_VISAREA,
1014         SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
1015 }
1016 
1017 /*************************************************************************
1018 |*
1019 |* Write user data
1020 |*
1021 \************************************************************************/
1022 
1023 void ViewShell::WriteUserData(String&)
1024 {
1025     // Das Schreiben unserer Daten erfolgt stets in WriteFrameViewData()
1026     WriteFrameViewData();
1027 }
1028 
1029 
1030 /*************************************************************************
1031 |*
1032 |* Lineale ein- / ausschalten
1033 |*
1034 \************************************************************************/
1035 
1036 void ViewShell::SetRuler(sal_Bool bRuler)
1037 {
1038     mbHasRulers = ( bRuler && !GetDocSh()->IsPreview() ); // no rulers on preview mode
1039 
1040     if (mpHorizontalRuler.get() != NULL)
1041     {
1042         if (mbHasRulers)
1043         {
1044             mpHorizontalRuler->Show();
1045         }
1046         else
1047         {
1048             mpHorizontalRuler->Hide();
1049         }
1050     }
1051 
1052     if (mpVerticalRuler.get() != NULL)
1053     {
1054         if (mbHasRulers)
1055         {
1056             mpVerticalRuler->Show();
1057         }
1058         else
1059         {
1060             mpVerticalRuler->Hide();
1061         }
1062     }
1063 
1064     OSL_ASSERT(GetViewShell()!=NULL);
1065     if (IsMainViewShell())
1066         GetViewShell()->InvalidateBorder();
1067 }
1068 
1069 /*************************************************************************
1070 |*
1071 |* AcceptDrop
1072 |*
1073 \************************************************************************/
1074 
1075 sal_Int8 ViewShell::AcceptDrop (
1076     const AcceptDropEvent& rEvt,
1077     DropTargetHelper& rTargetHelper,
1078     ::sd::Window* pTargetWindow,
1079     sal_uInt16 nPage,
1080     sal_uInt16 nLayer)
1081 {
1082     ::sd::View* pView = GetView();
1083     return( pView ? pView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE );
1084 }
1085 
1086 /*************************************************************************
1087 |*
1088 |* ExecuteDrop
1089 |*
1090 \************************************************************************/
1091 
1092 sal_Int8 ViewShell::ExecuteDrop (
1093     const ExecuteDropEvent& rEvt,
1094     DropTargetHelper& rTargetHelper,
1095     ::sd::Window* pTargetWindow,
1096     sal_uInt16 nPage,
1097     sal_uInt16 nLayer)
1098 {
1099     ::sd::View* pView = GetView();
1100     return( pView ? pView->ExecuteDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE );
1101 }
1102 
1103 #ifdef _MSC_VER
1104 #pragma optimize ( "", on )
1105 #endif
1106 
1107 void ViewShell::WriteUserDataSequence ( ::com::sun::star::uno::Sequence <
1108     ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse)
1109 {
1110     const sal_Int32 nIndex = rSequence.getLength();
1111     rSequence.realloc( nIndex + 1 );
1112 
1113     OSL_ASSERT (GetViewShell()!=NULL);
1114     // Get the view id from the view shell in the center pane.  This will
1115     // usually be the called view shell, but to be on the safe side we call
1116     // the main view shell explicitly.
1117     sal_uInt16 nViewID (IMPRESS_FACTORY_ID);
1118     if (GetViewShellBase().GetMainViewShell().get() != NULL)
1119         nViewID = GetViewShellBase().GetMainViewShell()->mpImpl->GetViewId();
1120     rSequence[nIndex].Name = rtl::OUString (
1121         RTL_CONSTASCII_USTRINGPARAM( sUNO_View_ViewId ) );
1122     rtl::OUStringBuffer sBuffer (
1123         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "view" ) ) );
1124     sBuffer.append( static_cast<sal_Int32>(nViewID));
1125     rSequence[nIndex].Value <<= sBuffer.makeStringAndClear();
1126 
1127     mpFrameView->WriteUserDataSequence( rSequence, bBrowse );
1128 }
1129 
1130 
1131 void ViewShell::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse )
1132 {
1133     mpFrameView->ReadUserDataSequence( rSequence, bBrowse );
1134 }
1135 
1136 void ViewShell::VisAreaChanged(const Rectangle& rRect)
1137 {
1138     OSL_ASSERT (GetViewShell()!=NULL);
1139     GetViewShell()->VisAreaChanged(rRect);
1140 }
1141 
1142 void ViewShell::SetWinViewPos(const Point& rWinPos, bool bUpdate)
1143 {
1144     if (mpContentWindow.get() != NULL)
1145     {
1146         mpContentWindow->SetWinViewPos(rWinPos);
1147 
1148         if ( bUpdate )
1149         {
1150             mpContentWindow->UpdateMapOrigin();
1151             mpContentWindow->Invalidate();
1152         }
1153     }
1154 
1155     if (mbHasRulers)
1156     {
1157         UpdateHRuler();
1158         UpdateVRuler();
1159     }
1160 
1161     UpdateScrollBars();
1162 
1163     Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
1164     Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
1165     VisAreaChanged(aVisAreaWin);
1166 
1167     ::sd::View* pView = GetView();
1168     if (pView)
1169     {
1170         pView->VisAreaChanged(GetActiveWindow());
1171     }
1172 }
1173 
1174 Point ViewShell::GetWinViewPos() const
1175 {
1176     return mpContentWindow->GetWinViewPos();
1177 }
1178 
1179 Point ViewShell::GetViewOrigin() const
1180 {
1181     return mpContentWindow->GetViewOrigin();
1182 }
1183 
1184 void ViewShell::AdaptDefaultsForChart(
1185     const uno::Reference < embed::XEmbeddedObject > & xEmbObj )
1186 {
1187     if( xEmbObj.is())
1188     {
1189         uno::Reference< chart2::XChartDocument > xChartDoc( xEmbObj->getComponent(), uno::UNO_QUERY );
1190         OSL_ENSURE( xChartDoc.is(), "Trying to set chart property to non-chart OLE" );
1191         if( !xChartDoc.is())
1192             return;
1193 
1194         try
1195         {
1196             // set background to transparent (none)
1197             uno::Reference< beans::XPropertySet > xPageProp( xChartDoc->getPageBackground());
1198             if( xPageProp.is())
1199                 xPageProp->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("FillStyle")),
1200                                              uno::makeAny( drawing::FillStyle_NONE ));
1201             // set no border
1202             if( xPageProp.is())
1203                 xPageProp->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("LineStyle")),
1204                                              uno::makeAny( drawing::LineStyle_NONE ));
1205         }
1206         catch( const uno::Exception & )
1207         {
1208             OSL_ENSURE( false, "Exception caught in AdaptDefaultsForChart" );
1209         }
1210     }
1211 }
1212 
1213 } // end of namespace sd
1214