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