sd/source/ui/view/viewshe2.cxx

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