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 <comphelper/classids.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 : #include <svx/charthelper.hxx>
73 :
74 : using namespace com::sun::star;
75 :
76 : namespace sd {
77 :
78 : const OUString aEmptyStr;
79 :
80 : /**
81 : * adjust Thumbpos and VisibleSize
82 : */
83 901 : void ViewShell::UpdateScrollBars()
84 : {
85 901 : if (mpHorizontalScrollBar.get() != NULL)
86 : {
87 901 : long nW = (long)(mpContentWindow->GetVisibleWidth() * 32000);
88 901 : long nX = (long)(mpContentWindow->GetVisibleX() * 32000);
89 901 : mpHorizontalScrollBar->SetVisibleSize(nW);
90 901 : mpHorizontalScrollBar->SetThumbPos(nX);
91 901 : nW = 32000 - nW;
92 901 : long nLine = (long) (mpContentWindow->GetScrlLineWidth() * nW);
93 901 : long nPage = (long) (mpContentWindow->GetScrlPageWidth() * nW);
94 901 : mpHorizontalScrollBar->SetLineSize(nLine);
95 901 : mpHorizontalScrollBar->SetPageSize(nPage);
96 : }
97 :
98 901 : if (mpVerticalScrollBar.get() != NULL)
99 : {
100 901 : long nH = (long)(mpContentWindow->GetVisibleHeight() * 32000);
101 901 : long nY = (long)(mpContentWindow->GetVisibleY() * 32000);
102 :
103 901 : if(IsPageFlipMode()) // ie in zoom mode where no panning
104 : {
105 41 : SdPage* pPage = static_cast<DrawViewShell*>(this)->GetActualPage();
106 41 : sal_uInt16 nCurPage = (pPage->GetPageNum() - 1) / 2;
107 41 : sal_uInt16 nTotalPages = GetDoc()->GetSdPageCount(pPage->GetPageKind());
108 41 : mpVerticalScrollBar->SetRange(Range(0,256*nTotalPages));
109 41 : mpVerticalScrollBar->SetVisibleSize(256);
110 41 : mpVerticalScrollBar->SetThumbPos(256*nCurPage);
111 41 : mpVerticalScrollBar->SetLineSize(256);
112 41 : mpVerticalScrollBar->SetPageSize(256);
113 : }
114 : else
115 : {
116 860 : mpVerticalScrollBar->SetRange(Range(0,32000));
117 860 : mpVerticalScrollBar->SetVisibleSize(nH);
118 860 : mpVerticalScrollBar->SetThumbPos(nY);
119 860 : nH = 32000 - nH;
120 860 : long nLine = (long) (mpContentWindow->GetScrlLineHeight() * nH);
121 860 : long nPage = (long) (mpContentWindow->GetScrlPageHeight() * nH);
122 860 : mpVerticalScrollBar->SetLineSize(nLine);
123 860 : mpVerticalScrollBar->SetPageSize(nPage);
124 : }
125 : }
126 :
127 901 : if (mbHasRulers)
128 : {
129 494 : UpdateHRuler();
130 494 : UpdateVRuler();
131 : }
132 :
133 901 : }
134 : /**
135 : * Handling for horizontal Scrollbars
136 : */
137 4 : IMPL_LINK(ViewShell, HScrollHdl, ScrollBar *, pHScroll )
138 : {
139 2 : return VirtHScrollHdl(pHScroll);
140 : }
141 :
142 : /**
143 : * virtual scroll handler for horizontal Scrollbars
144 : */
145 2 : long ViewShell::VirtHScrollHdl(ScrollBar* pHScroll)
146 : {
147 2 : long nDelta = pHScroll->GetDelta();
148 :
149 2 : if (nDelta != 0)
150 : {
151 2 : double fX = (double) pHScroll->GetThumbPos() / pHScroll->GetRange().Len();
152 :
153 : // scroll all windows of the column
154 2 : ::sd::View* pView = GetView();
155 2 : OutlinerView* pOLV = NULL;
156 :
157 2 : if (pView)
158 2 : pOLV = pView->GetTextEditOutlinerView();
159 :
160 2 : if (pOLV)
161 0 : pOLV->HideCursor();
162 :
163 2 : mpContentWindow->SetVisibleXY(fX, -1);
164 :
165 2 : Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT);
166 2 : Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) );
167 2 : aVisArea.SetPos(aVisAreaPos);
168 2 : GetDocSh()->SetVisArea(aVisArea);
169 :
170 2 : Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
171 2 : Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
172 2 : VisAreaChanged(aVisAreaWin);
173 :
174 2 : if (pView)
175 : {
176 2 : pView->VisAreaChanged(GetActiveWindow());
177 : }
178 :
179 2 : if (pOLV)
180 0 : pOLV->ShowCursor();
181 :
182 2 : if (mbHasRulers)
183 2 : UpdateHRuler();
184 :
185 : }
186 :
187 2 : return 0;
188 : }
189 :
190 : /**
191 : * handling for vertical Scrollbars
192 : */
193 0 : IMPL_LINK(ViewShell, VScrollHdl, ScrollBar *, pVScroll )
194 : {
195 0 : return VirtVScrollHdl(pVScroll);
196 : }
197 :
198 : /**
199 : * handling for vertical Scrollbars
200 : */
201 0 : long ViewShell::VirtVScrollHdl(ScrollBar* pVScroll)
202 : {
203 0 : if(IsPageFlipMode())
204 : {
205 0 : SdPage* pPage = static_cast<DrawViewShell*>(this)->GetActualPage();
206 0 : sal_uInt16 nCurPage = (pPage->GetPageNum() - 1) >> 1;
207 0 : sal_uInt16 nNewPage = (sal_uInt16)pVScroll->GetThumbPos()/256;
208 0 : if( nCurPage != nNewPage )
209 0 : static_cast<DrawViewShell*>(this)->SwitchPage(nNewPage);
210 : }
211 : else //panning mode
212 : {
213 0 : double fY = (double) pVScroll->GetThumbPos() / pVScroll->GetRange().Len();
214 :
215 0 : ::sd::View* pView = GetView();
216 0 : OutlinerView* pOLV = NULL;
217 :
218 0 : if (pView)
219 0 : pOLV = pView->GetTextEditOutlinerView();
220 :
221 0 : if (pOLV)
222 0 : pOLV->HideCursor();
223 :
224 0 : mpContentWindow->SetVisibleXY(-1, fY);
225 :
226 0 : Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT);
227 0 : Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) );
228 0 : aVisArea.SetPos(aVisAreaPos);
229 0 : GetDocSh()->SetVisArea(aVisArea);
230 :
231 0 : Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
232 0 : Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
233 0 : VisAreaChanged(aVisAreaWin);
234 :
235 0 : if (pView)
236 : {
237 0 : pView->VisAreaChanged(GetActiveWindow());
238 : }
239 :
240 0 : if (pOLV)
241 0 : pOLV->ShowCursor();
242 :
243 0 : if (mbHasRulers)
244 0 : UpdateVRuler();
245 :
246 : }
247 :
248 0 : return 0;
249 : }
250 :
251 0 : SvxRuler* ViewShell::CreateHRuler(::sd::Window* , bool )
252 : {
253 0 : return NULL;
254 : }
255 :
256 0 : SvxRuler* ViewShell::CreateVRuler(::sd::Window* )
257 : {
258 0 : return NULL;
259 : }
260 :
261 0 : void ViewShell::UpdateHRuler()
262 : {
263 0 : }
264 :
265 0 : void ViewShell::UpdateVRuler()
266 : {
267 0 : }
268 :
269 : /**
270 : * Scroll a specific number of lines. Is used in the automatic scrolling
271 : * (character/drag).
272 : */
273 0 : void ViewShell::ScrollLines(long nLinesX, long nLinesY)
274 : {
275 0 : if ( nLinesX )
276 : {
277 0 : nLinesX *= mpHorizontalScrollBar->GetLineSize();
278 : }
279 0 : if ( nLinesY )
280 : {
281 0 : nLinesY *= mpVerticalScrollBar->GetLineSize();
282 : }
283 :
284 0 : Scroll(nLinesX, nLinesY);
285 0 : }
286 :
287 0 : void ViewShell::Scroll(long nScrollX, long nScrollY)
288 : {
289 0 : if (nScrollX)
290 : {
291 0 : long nNewThumb = mpHorizontalScrollBar->GetThumbPos() + nScrollX;
292 0 : mpHorizontalScrollBar->SetThumbPos(nNewThumb);
293 : }
294 0 : if (nScrollY)
295 : {
296 0 : long nNewThumb = mpVerticalScrollBar->GetThumbPos() + nScrollY;
297 0 : mpVerticalScrollBar->SetThumbPos(nNewThumb);
298 : }
299 0 : double fX = (double) mpHorizontalScrollBar->GetThumbPos() /
300 0 : mpHorizontalScrollBar->GetRange().Len();
301 0 : double fY = (double) mpVerticalScrollBar->GetThumbPos() /
302 0 : mpVerticalScrollBar->GetRange().Len();
303 :
304 0 : GetActiveWindow()->SetVisibleXY(fX, fY);
305 :
306 0 : Rectangle aVisArea = GetDocSh()->GetVisArea(ASPECT_CONTENT);
307 0 : Point aVisAreaPos = GetActiveWindow()->PixelToLogic( Point(0,0) );
308 0 : aVisArea.SetPos(aVisAreaPos);
309 0 : GetDocSh()->SetVisArea(aVisArea);
310 :
311 0 : Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
312 0 : Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
313 0 : VisAreaChanged(aVisAreaWin);
314 :
315 0 : ::sd::View* pView = GetView();
316 0 : if (pView)
317 : {
318 0 : pView->VisAreaChanged(GetActiveWindow());
319 : }
320 :
321 0 : if (mbHasRulers)
322 : {
323 0 : UpdateHRuler();
324 0 : UpdateVRuler();
325 : }
326 0 : }
327 :
328 : /**
329 : * Set zoom factor for all split windows.
330 : */
331 0 : void ViewShell::SetZoom(long nZoom)
332 : {
333 0 : Fraction aUIScale(nZoom, 100);
334 0 : aUIScale *= GetDoc()->GetUIScale();
335 :
336 0 : if (mpHorizontalRuler.get() != NULL)
337 0 : mpHorizontalRuler->SetZoom(aUIScale);
338 :
339 0 : if (mpVerticalRuler.get() != NULL)
340 0 : mpVerticalRuler->SetZoom(aUIScale);
341 :
342 0 : if (mpContentWindow.get() != NULL)
343 : {
344 0 : mpContentWindow->SetZoomIntegral(nZoom);
345 :
346 : // #i74769# Here is a 2nd way (besides Window::Scroll) to set the visible prt
347 : // of the window. It needs - like Scroll(ScrollFlags::Children) does - also to move
348 : // the child windows. I am trying InvalidateFlags::Children here which makes things better,
349 : // but does not solve the problem completely. Neet to ask PL.
350 0 : mpContentWindow->Invalidate(InvalidateFlags::Children);
351 : }
352 :
353 0 : Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
354 0 : Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
355 0 : VisAreaChanged(aVisAreaWin);
356 :
357 0 : ::sd::View* pView = GetView();
358 0 : if (pView)
359 : {
360 0 : pView->VisAreaChanged(GetActiveWindow());
361 : }
362 :
363 0 : UpdateScrollBars();
364 0 : }
365 :
366 : /**
367 : * Set zoom rectangle for active window. Sets all split windows to the same zoom
368 : * factor.
369 : */
370 430 : void ViewShell::SetZoomRect(const Rectangle& rZoomRect)
371 : {
372 430 : long nZoom = GetActiveWindow()->SetZoomRect(rZoomRect);
373 430 : Fraction aUIScale(nZoom, 100);
374 430 : aUIScale *= GetDoc()->GetUIScale();
375 :
376 430 : Point aPos = GetActiveWindow()->GetWinViewPos();
377 :
378 430 : if (mpHorizontalRuler.get() != NULL)
379 230 : mpHorizontalRuler->SetZoom(aUIScale);
380 :
381 430 : if (mpVerticalRuler.get() != NULL)
382 230 : mpVerticalRuler->SetZoom(aUIScale);
383 :
384 430 : if (mpContentWindow.get() != NULL)
385 : {
386 430 : Point aNewPos = mpContentWindow->GetWinViewPos();
387 430 : aNewPos.X() = aPos.X();
388 430 : aNewPos.Y() = aPos.Y();
389 430 : mpContentWindow->SetZoomIntegral(nZoom);
390 430 : mpContentWindow->SetWinViewPos(aNewPos);
391 430 : mpContentWindow->UpdateMapOrigin();
392 :
393 : // When tiled rendering, UpdateMapOrigin() doesn't touch the map mode.
394 430 : if (!GetDoc()->isTiledRendering())
395 : // #i74769# see above
396 415 : mpContentWindow->Invalidate(InvalidateFlags::Children);
397 : }
398 :
399 430 : Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
400 430 : Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
401 430 : VisAreaChanged(aVisAreaWin);
402 :
403 430 : ::sd::View* pView = GetView();
404 430 : if (pView)
405 : {
406 430 : pView->VisAreaChanged(GetActiveWindow());
407 : }
408 :
409 430 : UpdateScrollBars();
410 430 : }
411 :
412 : /**
413 : * Initialize imaging parameters for all split windows.
414 : */
415 177 : void ViewShell::InitWindows(const Point& rViewOrigin, const Size& rViewSize,
416 : const Point& rWinPos, bool bUpdate)
417 : {
418 177 : if (mpContentWindow.get() != NULL)
419 : {
420 177 : mpContentWindow->SetViewOrigin(rViewOrigin);
421 177 : mpContentWindow->SetViewSize(rViewSize);
422 177 : mpContentWindow->SetWinViewPos(rWinPos);
423 :
424 177 : if ( bUpdate )
425 : {
426 44 : mpContentWindow->UpdateMapOrigin();
427 44 : mpContentWindow->Invalidate();
428 : }
429 : }
430 :
431 177 : Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
432 177 : Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
433 177 : VisAreaChanged(aVisAreaWin);
434 :
435 177 : ::sd::View* pView = GetView();
436 177 : if (pView)
437 : {
438 177 : pView->VisAreaChanged(GetActiveWindow());
439 : }
440 177 : }
441 :
442 : /**
443 : * Invalidate all split windows below the ?provided rectangle.
444 : */
445 78 : void ViewShell::InvalidateWindows()
446 : {
447 78 : if (mpContentWindow.get() != NULL)
448 78 : mpContentWindow->Invalidate();
449 78 : }
450 :
451 : /**
452 : * Draw a selection rectangle with the ?provided pen on all split windows.
453 : */
454 0 : void ViewShell::DrawMarkRect(const Rectangle& rRect) const
455 : {
456 0 : if (mpContentWindow.get() != NULL)
457 : {
458 0 : mpContentWindow->InvertTracking(rRect, SHOWTRACK_OBJECT | SHOWTRACK_WINDOW);
459 : }
460 0 : }
461 :
462 0 : void ViewShell::SetPageSizeAndBorder(PageKind ePageKind, const Size& rNewSize,
463 : long nLeft, long nRight,
464 : long nUpper, long nLower, bool bScaleAll,
465 : Orientation eOrientation, sal_uInt16 nPaperBin,
466 : bool bBackgroundFullSize)
467 : {
468 0 : SdPage* pPage = 0;
469 0 : SdUndoGroup* pUndoGroup = NULL;
470 0 : pUndoGroup = new SdUndoGroup(GetDoc());
471 0 : OUString aString(SdResId(STR_UNDO_CHANGE_PAGEFORMAT));
472 0 : pUndoGroup->SetComment(aString);
473 0 : SfxViewShell* pViewShell = GetViewShell();
474 : OSL_ASSERT (pViewShell!=NULL);
475 :
476 0 : sal_uInt16 i, nPageCnt = GetDoc()->GetMasterSdPageCount(ePageKind);
477 :
478 0 : Broadcast (ViewShellHint(ViewShellHint::HINT_PAGE_RESIZE_START));
479 :
480 0 : for (i = 0; i < nPageCnt; i++)
481 : {
482 : // first, handle all master pages
483 0 : pPage = GetDoc()->GetMasterSdPage(i, ePageKind);
484 :
485 : SdUndoAction* pUndo = new SdPageFormatUndoAction(GetDoc(), pPage,
486 0 : pPage->GetSize(),
487 0 : pPage->GetLftBorder(), pPage->GetRgtBorder(),
488 0 : pPage->GetUppBorder(), pPage->GetLwrBorder(),
489 0 : pPage->GetOrientation(),
490 0 : pPage->GetPaperBin(),
491 0 : pPage->IsBackgroundFullSize(),
492 : rNewSize,
493 : nLeft, nRight,
494 : nUpper, nLower,
495 : bScaleAll,
496 : eOrientation,
497 : nPaperBin,
498 0 : bBackgroundFullSize);
499 0 : pUndoGroup->AddAction(pUndo);
500 :
501 0 : if (rNewSize.Width() > 0 ||
502 0 : nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0)
503 : {
504 0 : Rectangle aNewBorderRect(nLeft, nUpper, nRight, nLower);
505 0 : pPage->ScaleObjects(rNewSize, aNewBorderRect, bScaleAll);
506 :
507 0 : if (rNewSize.Width() > 0)
508 0 : pPage->SetSize(rNewSize);
509 : }
510 :
511 0 : if( nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0 )
512 : {
513 0 : pPage->SetBorder(nLeft, nUpper, nRight, nLower);
514 : }
515 :
516 0 : pPage->SetOrientation(eOrientation);
517 0 : pPage->SetPaperBin( nPaperBin );
518 0 : pPage->SetBackgroundFullSize( bBackgroundFullSize );
519 :
520 0 : if ( ePageKind == PK_STANDARD )
521 0 : GetDoc()->GetMasterSdPage(i, PK_NOTES)->CreateTitleAndLayout();
522 :
523 0 : pPage->CreateTitleAndLayout();
524 : }
525 :
526 0 : nPageCnt = GetDoc()->GetSdPageCount(ePageKind);
527 :
528 0 : for (i = 0; i < nPageCnt; i++)
529 : {
530 : // then, handle all pages
531 0 : pPage = GetDoc()->GetSdPage(i, ePageKind);
532 :
533 : SdUndoAction* pUndo = new SdPageFormatUndoAction(GetDoc(), pPage,
534 0 : pPage->GetSize(),
535 0 : pPage->GetLftBorder(), pPage->GetRgtBorder(),
536 0 : pPage->GetUppBorder(), pPage->GetLwrBorder(),
537 0 : pPage->GetOrientation(),
538 0 : pPage->GetPaperBin(),
539 0 : pPage->IsBackgroundFullSize(),
540 : rNewSize,
541 : nLeft, nRight,
542 : nUpper, nLower,
543 : bScaleAll,
544 : eOrientation,
545 : nPaperBin,
546 0 : bBackgroundFullSize);
547 0 : pUndoGroup->AddAction(pUndo);
548 :
549 0 : if (rNewSize.Width() > 0 ||
550 0 : nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0)
551 : {
552 0 : Rectangle aNewBorderRect(nLeft, nUpper, nRight, nLower);
553 0 : pPage->ScaleObjects(rNewSize, aNewBorderRect, bScaleAll);
554 :
555 0 : if (rNewSize.Width() > 0)
556 0 : pPage->SetSize(rNewSize);
557 : }
558 :
559 0 : if( nLeft >= 0 || nRight >= 0 || nUpper >= 0 || nLower >= 0 )
560 : {
561 0 : pPage->SetBorder(nLeft, nUpper, nRight, nLower);
562 : }
563 :
564 0 : pPage->SetOrientation(eOrientation);
565 0 : pPage->SetPaperBin( nPaperBin );
566 0 : pPage->SetBackgroundFullSize( bBackgroundFullSize );
567 :
568 0 : if ( ePageKind == PK_STANDARD )
569 : {
570 0 : SdPage* pNotesPage = GetDoc()->GetSdPage(i, PK_NOTES);
571 0 : pNotesPage->SetAutoLayout( pNotesPage->GetAutoLayout() );
572 : }
573 :
574 0 : pPage->SetAutoLayout( pPage->GetAutoLayout() );
575 : }
576 :
577 : // adjust handout page to new format of the standard page
578 0 : if( (ePageKind == PK_STANDARD) || (ePageKind == PK_HANDOUT) )
579 0 : GetDoc()->GetSdPage(0, PK_HANDOUT)->CreateTitleAndLayout(true);
580 :
581 : // handed over undo group to undo manager
582 0 : pViewShell->GetViewFrame()->GetObjectShell()
583 0 : ->GetUndoManager()->AddUndoAction(pUndoGroup);
584 :
585 0 : long nWidth = pPage->GetSize().Width();
586 0 : long nHeight = pPage->GetSize().Height();
587 :
588 0 : Point aPageOrg = Point(nWidth, nHeight / 2);
589 0 : Size aViewSize = Size(nWidth * 3, nHeight * 2);
590 :
591 0 : InitWindows(aPageOrg, aViewSize, Point(-1, -1), true);
592 :
593 0 : Point aVisAreaPos;
594 :
595 0 : if ( GetDocSh()->GetCreateMode() == SfxObjectCreateMode::EMBEDDED )
596 : {
597 0 : aVisAreaPos = GetDocSh()->GetVisArea(ASPECT_CONTENT).TopLeft();
598 : }
599 :
600 0 : ::sd::View* pView = GetView();
601 0 : if (pView)
602 : {
603 0 : pView->SetWorkArea(Rectangle(Point() - aVisAreaPos - aPageOrg, aViewSize));
604 : }
605 :
606 0 : UpdateScrollBars();
607 :
608 0 : Point aNewOrigin(pPage->GetLftBorder(), pPage->GetUppBorder());
609 :
610 0 : if (pView)
611 : {
612 0 : pView->GetSdrPageView()->SetPageOrigin(aNewOrigin);
613 : }
614 :
615 0 : pViewShell->GetViewFrame()->GetBindings().Invalidate(SID_RULER_NULL_OFFSET);
616 :
617 : // zoom onto (new) page size
618 : pViewShell->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_PAGE,
619 0 : SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
620 :
621 0 : Broadcast (ViewShellHint(ViewShellHint::HINT_PAGE_RESIZE_END));
622 0 : }
623 :
624 : /**
625 : * Set zoom factor for InPlace
626 : */
627 0 : void ViewShell::SetZoomFactor(const Fraction& rZoomX, const Fraction&)
628 : {
629 0 : long nZoom = (long)((double) rZoomX * 100);
630 0 : SetZoom(nZoom);
631 0 : }
632 :
633 630 : void ViewShell::SetActiveWindow (::sd::Window* pWin)
634 : {
635 630 : SfxViewShell* pViewShell = GetViewShell();
636 : OSL_ASSERT (pViewShell!=NULL);
637 :
638 630 : if (pViewShell->GetWindow() != pWin)
639 : {
640 : // #i31551# was wrong, it may have been a problem with the repaint at that time.
641 : // For transparent form controls, it is necessary to have that flag set, all apps
642 : // do set it. Enabling again.
643 630 : if (pWin)
644 : {
645 630 : pWin->EnableChildTransparentMode();
646 : }
647 : }
648 :
649 630 : if (mpActiveWindow.get() != pWin)
650 197 : mpActiveWindow = pWin;
651 :
652 : // The rest of this function is not guarded anymore against calling this
653 : // method with an already active window because the functions may still
654 : // point to the old window when the new one has already been assigned to
655 : // pWindow elsewhere.
656 630 : ::sd::View* pView = GetView();
657 630 : if (pView)
658 : {
659 433 : pView->SetActualWin(pWin);
660 : }
661 630 : if(HasCurrentFunction())
662 : {
663 433 : GetCurrentFunction()->SetWindow(pWin);
664 : }
665 630 : }
666 :
667 0 : bool ViewShell::RequestHelp(const HelpEvent& rHEvt, ::sd::Window*)
668 : {
669 0 : bool bReturn = false;
670 :
671 0 : if (bool(rHEvt.GetMode()))
672 : {
673 0 : if( GetView() )
674 0 : bReturn = GetView()->getSmartTags().RequestHelp(rHEvt);
675 :
676 0 : if(!bReturn && HasCurrentFunction())
677 : {
678 0 : bReturn = GetCurrentFunction()->RequestHelp(rHEvt);
679 : }
680 : }
681 :
682 0 : return bReturn;
683 : }
684 :
685 0 : void ViewShell::SetFrameView (FrameView* pNewFrameView)
686 : {
687 0 : mpFrameView = pNewFrameView;
688 0 : ReadFrameViewData (mpFrameView);
689 0 : }
690 :
691 : /*************************************************************************
692 : |*
693 : |* Read FrameViews data and set actual views data
694 : |*
695 : \************************************************************************/
696 :
697 0 : void ViewShell::ReadFrameViewData(FrameView*)
698 : {
699 0 : }
700 :
701 : /*************************************************************************
702 : |*
703 : |* Write actual views data to FrameView
704 : |*
705 : \************************************************************************/
706 :
707 0 : void ViewShell::WriteFrameViewData()
708 : {
709 0 : }
710 :
711 0 : bool ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
712 : {
713 0 : ErrCode aErrCode = 0;
714 :
715 0 : SfxErrorContext aEC(ERRCTX_SO_DOVERB, GetActiveWindow(), RID_SO_ERRCTX);
716 0 : bool bAbort = false;
717 0 : GetDocSh()->SetWaitCursor( true );
718 0 : SfxViewShell* pViewShell = GetViewShell();
719 : OSL_ASSERT (pViewShell!=NULL);
720 0 : bool bChangeDefaultsForChart = false;
721 0 : OUString aName;
722 :
723 0 : uno::Reference < embed::XEmbeddedObject > xObj = pObj->GetObjRef();
724 0 : if ( !xObj.is() )
725 : {
726 : // provide OLE object to empty OLE object
727 0 : aName = pObj->GetProgName();
728 0 : OUString aObjName;
729 0 : SvGlobalName aClass;
730 :
731 0 : if( aName == "StarChart" || aName == "StarOrg" )
732 : {
733 0 : if( SvtModuleOptions().IsChart() )
734 : {
735 0 : aClass = SvGlobalName( SO3_SCH_CLASSID );
736 0 : bChangeDefaultsForChart = true;
737 : }
738 : }
739 0 : else if( aName == "StarCalc" )
740 : {
741 0 : if( SvtModuleOptions().IsCalc() )
742 0 : aClass = SvGlobalName( SO3_SC_CLASSID );
743 : }
744 0 : else if( aName == "StarMath" )
745 : {
746 0 : if( SvtModuleOptions().IsMath() )
747 0 : aClass = SvGlobalName( SO3_SM_CLASSID );
748 : }
749 :
750 0 : if ( aClass != SvGlobalName() )
751 0 : xObj = GetDocSh()->GetEmbeddedObjectContainer().CreateEmbeddedObject( aClass.GetByteSequence(), aObjName );
752 :
753 0 : if( !xObj.is() )
754 : {
755 0 : aName.clear();
756 :
757 : // call dialog "insert OLE object"
758 0 : GetDocSh()->SetWaitCursor( false );
759 : pViewShell->GetViewFrame()->GetDispatcher()->Execute(
760 : SID_INSERT_OBJECT,
761 0 : SfxCallMode::SYNCHRON | SfxCallMode::RECORD);
762 0 : xObj = pObj->GetObjRef();
763 0 : GetDocSh()->SetWaitCursor( true );
764 :
765 0 : if (!xObj.is())
766 : {
767 0 : bAbort = true;
768 : }
769 : }
770 :
771 0 : if ( xObj.is() )
772 : {
773 : // OLE object is no longer empty
774 0 : pObj->SetEmptyPresObj(false);
775 0 : pObj->SetOutlinerParaObject(NULL);
776 0 : pObj->SetGraphic(NULL);
777 :
778 : // the empty OLE object gets a new IPObj
779 0 : if (!aName.isEmpty())
780 : {
781 0 : pObj->SetObjRef(xObj);
782 0 : pObj->SetName(aObjName);
783 0 : pObj->SetPersistName(aObjName);
784 : }
785 : else
786 : {
787 : // insertion was done by the dialog
788 0 : pObj->SetObjRef(xObj);
789 : }
790 :
791 0 : Rectangle aRect = pObj->GetLogicRect();
792 :
793 0 : if ( pObj->GetAspect() != embed::Aspects::MSOLE_ICON )
794 : {
795 0 : awt::Size aSz;
796 0 : aSz.Width = aRect.GetWidth();
797 0 : aSz.Height = aRect.GetHeight();
798 0 : xObj->setVisualAreaSize( pObj->GetAspect(), aSz );
799 : }
800 :
801 0 : GetViewShellBase().SetVerbs( xObj->getSupportedVerbs() );
802 :
803 0 : nVerb = SVVERB_SHOW;
804 : }
805 : else
806 : {
807 0 : aErrCode = ERRCODE_SFX_OLEGENERAL;
808 0 : }
809 : }
810 :
811 0 : if( aErrCode == 0 )
812 : {
813 0 : ::sd::View* pView = GetView();
814 :
815 0 : if (pView->IsTextEdit())
816 : {
817 0 : pView->SdrEndTextEdit();
818 : }
819 :
820 : SfxInPlaceClient* pSdClient =
821 : static_cast<Client*>(pViewShell->FindIPClient(
822 0 : pObj->GetObjRef(), GetActiveWindow()));
823 :
824 0 : if ( !pSdClient )
825 : {
826 0 : pSdClient = new Client(pObj, this, GetActiveWindow());
827 : }
828 :
829 0 : Rectangle aRect = pObj->GetLogicRect();
830 :
831 : {
832 : // #i118485# center on BoundRect for activation,
833 : // OLE may be sheared/rotated now
834 0 : const Rectangle& rBoundRect = pObj->GetCurrentBoundRect();
835 0 : const Point aDelta(rBoundRect.Center() - aRect.Center());
836 0 : aRect.Move(aDelta.X(), aDelta.Y());
837 : }
838 :
839 0 : Size aDrawSize = aRect.GetSize();
840 :
841 0 : MapMode aMapMode( GetDoc()->GetScaleUnit() );
842 0 : Size aObjAreaSize = pObj->GetOrigObjSize( &aMapMode );
843 0 : if( pObj->IsChart() ) //charts never should be stretched see #i84323# for example
844 0 : aObjAreaSize = aDrawSize;
845 :
846 0 : Fraction aScaleWidth (aDrawSize.Width(), aObjAreaSize.Width() );
847 0 : Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() );
848 0 : aScaleWidth.ReduceInaccurate(10); // kompatibel zum SdrOle2Obj
849 0 : aScaleHeight.ReduceInaccurate(10);
850 0 : pSdClient->SetSizeScale(aScaleWidth, aScaleHeight);
851 :
852 : // visible section is only changed in-place!
853 0 : aRect.SetSize(aObjAreaSize);
854 : // the object area size must be set after scaling, since it triggers the resizing
855 0 : pSdClient->SetObjArea(aRect);
856 :
857 0 : if( bChangeDefaultsForChart && xObj.is())
858 : {
859 0 : ChartHelper::AdaptDefaultsForChart( xObj );
860 : }
861 :
862 0 : pSdClient->DoVerb(nVerb); // if necessary, ErrCode is outputted by Sfx
863 0 : pViewShell->GetViewFrame()->GetBindings().Invalidate(
864 0 : SID_NAVIGATOR_STATE, true, false);
865 : }
866 :
867 0 : GetDocSh()->SetWaitCursor( false );
868 :
869 0 : if (aErrCode != 0 && !bAbort)
870 : {
871 0 : ErrorHandler::HandleError(* new StringErrorInfo(aErrCode, OUString() ) );
872 : }
873 :
874 0 : return aErrCode == 0;
875 : }
876 :
877 : /**
878 : * @returns enclosing rectangle of all (split-) windows.
879 : */
880 2 : const Rectangle& ViewShell::GetAllWindowRect()
881 : {
882 : maAllWindowRectangle.SetPos(
883 2 : mpContentWindow->OutputToScreenPixel(Point(0,0)));
884 2 : return maAllWindowRectangle;
885 : }
886 :
887 0 : void ViewShell::ReadUserData(const OUString&)
888 : {
889 : // zoom onto VisArea from FrameView
890 : GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_VISAREA,
891 0 : SfxCallMode::ASYNCHRON | SfxCallMode::RECORD);
892 0 : }
893 :
894 0 : void ViewShell::WriteUserData(OUString&)
895 : {
896 : // writing of our data is always done in WriteFrameViewData()
897 0 : WriteFrameViewData();
898 0 : }
899 :
900 : /**
901 : * Switch ruler on/off
902 : */
903 86 : void ViewShell::SetRuler(bool bRuler)
904 : {
905 86 : mbHasRulers = ( bRuler && !GetDocSh()->IsPreview() ); // no rulers on preview mode
906 :
907 86 : if (mpHorizontalRuler.get() != NULL)
908 : {
909 0 : if (mbHasRulers)
910 : {
911 0 : mpHorizontalRuler->Show();
912 : }
913 : else
914 : {
915 0 : mpHorizontalRuler->Hide();
916 : }
917 : }
918 :
919 86 : if (mpVerticalRuler.get() != NULL)
920 : {
921 0 : if (mbHasRulers)
922 : {
923 0 : mpVerticalRuler->Show();
924 : }
925 : else
926 : {
927 0 : mpVerticalRuler->Hide();
928 : }
929 : }
930 :
931 : OSL_ASSERT(GetViewShell()!=NULL);
932 86 : if (IsMainViewShell())
933 0 : GetViewShell()->InvalidateBorder();
934 86 : }
935 :
936 0 : sal_Int8 ViewShell::AcceptDrop (
937 : const AcceptDropEvent& rEvt,
938 : DropTargetHelper& rTargetHelper,
939 : ::sd::Window* pTargetWindow,
940 : sal_uInt16 nPage,
941 : sal_uInt16 nLayer)
942 : {
943 0 : ::sd::View* pView = GetView();
944 0 : return( pView ? pView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE );
945 : }
946 :
947 0 : sal_Int8 ViewShell::ExecuteDrop (
948 : const ExecuteDropEvent& rEvt,
949 : DropTargetHelper& rTargetHelper,
950 : ::sd::Window* pTargetWindow,
951 : sal_uInt16 nPage,
952 : sal_uInt16 nLayer)
953 : {
954 0 : ::sd::View* pView = GetView();
955 0 : return( pView ? pView->ExecuteDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE );
956 : }
957 :
958 112 : void ViewShell::WriteUserDataSequence ( css::uno::Sequence < css::beans::PropertyValue >& rSequence, bool bBrowse)
959 : {
960 112 : const sal_Int32 nIndex = rSequence.getLength();
961 112 : rSequence.realloc( nIndex + 1 );
962 :
963 : OSL_ASSERT (GetViewShell()!=NULL);
964 : // Get the view id from the view shell in the center pane. This will
965 : // usually be the called view shell, but to be on the safe side we call
966 : // the main view shell explicitly.
967 112 : sal_uInt16 nViewID (IMPRESS_FACTORY_ID);
968 112 : if (GetViewShellBase().GetMainViewShell().get() != NULL)
969 112 : nViewID = GetViewShellBase().GetMainViewShell()->mpImpl->GetViewId();
970 112 : rSequence[nIndex].Name = sUNO_View_ViewId;
971 112 : OUStringBuffer sBuffer( "view" );
972 112 : sBuffer.append( static_cast<sal_Int32>(nViewID));
973 112 : rSequence[nIndex].Value <<= sBuffer.makeStringAndClear();
974 :
975 112 : mpFrameView->WriteUserDataSequence( rSequence, bBrowse );
976 112 : }
977 :
978 126 : void ViewShell::ReadUserDataSequence ( const css::uno::Sequence < css::beans::PropertyValue >& rSequence, bool bBrowse )
979 : {
980 126 : mpFrameView->ReadUserDataSequence( rSequence, bBrowse );
981 126 : }
982 :
983 909 : void ViewShell::VisAreaChanged(const Rectangle& rRect)
984 : {
985 : OSL_ASSERT (GetViewShell()!=NULL);
986 909 : GetViewShell()->VisAreaChanged(rRect);
987 909 : }
988 :
989 0 : void ViewShell::SetWinViewPos(const Point& rWinPos, bool bUpdate)
990 : {
991 0 : if (mpContentWindow.get() != NULL)
992 : {
993 0 : mpContentWindow->SetWinViewPos(rWinPos);
994 :
995 0 : if ( bUpdate )
996 : {
997 0 : mpContentWindow->UpdateMapOrigin();
998 0 : mpContentWindow->Invalidate();
999 : }
1000 : }
1001 :
1002 0 : if (mbHasRulers)
1003 : {
1004 0 : UpdateHRuler();
1005 0 : UpdateVRuler();
1006 : }
1007 :
1008 0 : UpdateScrollBars();
1009 :
1010 0 : Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
1011 0 : Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
1012 0 : VisAreaChanged(aVisAreaWin);
1013 :
1014 0 : ::sd::View* pView = GetView();
1015 0 : if (pView)
1016 : {
1017 0 : pView->VisAreaChanged(GetActiveWindow());
1018 : }
1019 0 : }
1020 :
1021 0 : Point ViewShell::GetWinViewPos() const
1022 : {
1023 0 : return mpContentWindow->GetWinViewPos();
1024 : }
1025 :
1026 0 : Point ViewShell::GetViewOrigin() const
1027 : {
1028 0 : return mpContentWindow->GetViewOrigin();
1029 : }
1030 :
1031 66 : } // end of namespace sd
1032 :
1033 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
