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( GetView() )
 802             bReturn = GetView()->getSmartTags().RequestHelp(rHEvt);
 803
 804         if(!bReturn && HasCurrentFunction())
 805         {
 806             bReturn = GetCurrentFunction()->RequestHelp(rHEvt);
 807         }
 808     }
 809
 810     return(bReturn);
 811 }
 812
 813
 814
 815
 816 FrameView* ViewShell::GetFrameView (void)
 817 {
 818     return mpFrameView;
 819 }
 820
 821
 822
 823
 824 void ViewShell::SetFrameView (FrameView* pNewFrameView)
 825 {
 826     mpFrameView = pNewFrameView;
 827     ReadFrameViewData (mpFrameView);
 828 }
 829
 830
 831
 832
 833 /*************************************************************************
 834 |*
 835 |* Read FrameViews data and set actual views data
 836 |*
 837 \************************************************************************/
 838
 839 void ViewShell::ReadFrameViewData(FrameView*)
 840 {
 841 }
 842
 843
 844
 845 /*************************************************************************
 846 |*
 847 |* Write actual views data to FrameView
 848 |*
 849 \************************************************************************/
 850
 851 void ViewShell::WriteFrameViewData()
 852 {
 853 }
 854
 855 /*************************************************************************
 856 |*
 857 |* Auf allen Split-Windows ein Update erzwingen.
 858 |*
 859 \************************************************************************/
 860
 861 void ViewShell::UpdateWindows()
 862 {
 863     if (mpContentWindow.get() != NULL)
 864         mpContentWindow->Update();
 865 }
 866
 867 /*************************************************************************
 868 |*
 869 |* OLE-Object aktivieren
 870 |*
 871 \************************************************************************/
 872
 873 BOOL ViewShell::ActivateObject(SdrOle2Obj* pObj, long nVerb)
 874 {
 875     ErrCode aErrCode = 0;
 876
 877     SfxErrorContext aEC(ERRCTX_SO_DOVERB, GetActiveWindow(), RID_SO_ERRCTX);
 878     BOOL bAbort = FALSE;
 879     GetDocSh()->SetWaitCursor( TRUE );
 880     SfxViewShell* pViewShell = GetViewShell();
 881     OSL_ASSERT (pViewShell!=NULL);
 882     bool bChangeDefaultsForChart = false;
 883
 884     uno::Reference < embed::XEmbeddedObject > xObj = pObj->GetObjRef();
 885     if ( !xObj.is() )
 886     {
 887         /**********************************************************
 888         * Leeres OLE-Objekt mit OLE-Objekt versehen
 889         **********************************************************/
 890         String aName = pObj->GetProgName();
 891         ::rtl::OUString aObjName;
 892         SvGlobalName aClass;
 893
 894         if( aName.EqualsAscii( "StarChart" ) || aName.EqualsAscii("StarOrg") )
 895         {
 896             if( SvtModuleOptions().IsChart() )
 897             {
 898                 aClass = SvGlobalName( SO3_SCH_CLASSID );
 899                 bChangeDefaultsForChart = true;
 900             }
 901         }
 902         else if( aName.EqualsAscii( "StarCalc" ))
 903         {
 904             if( SvtModuleOptions().IsCalc() )
 905                 aClass = SvGlobalName( SO3_SC_CLASSID );
 906         }
 907         else if( aName.EqualsAscii( "StarMath" ))
 908         {
 909             if( SvtModuleOptions().IsMath() )
 910                 aClass = SvGlobalName( SO3_SM_CLASSID );
 911         }
 912
 913         if ( aClass != SvGlobalName() )
 914             xObj = GetDocSh()->GetEmbeddedObjectContainer().CreateEmbeddedObject( aClass.GetByteSequence(), aObjName );
 915
 916         if( !xObj.is() )
 917         {
 918             aName = String();
 919
 920             // Dialog "OLE-Objekt einfuegen" aufrufen
 921             GetDocSh()->SetWaitCursor( FALSE );
 922             pViewShell->GetViewFrame()->GetDispatcher()->Execute(
 923                 SID_INSERT_OBJECT,
 924                 SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD);
 925             xObj = pObj->GetObjRef();
 926             GetDocSh()->SetWaitCursor( TRUE );
 927
 928             if (!xObj.is())
 929             {
 930                 bAbort = TRUE;
 931             }
 932         }
 933
 934         if ( xObj.is() )
 935         {
 936             /******************************************************
 937             * OLE-Objekt ist nicht mehr leer
 938             ******************************************************/
 939             pObj->SetEmptyPresObj(FALSE);
 940             pObj->SetOutlinerParaObject(NULL);
 941             pObj->SetGraphic(NULL);
 942
 943             /******************************************************
 944             * Das leere OLE-Objekt bekommt ein neues IPObj
 945             ******************************************************/
 946             if (aName.Len())
 947             {
 948                 pObj->SetObjRef(xObj);
 949                 pObj->SetName(aObjName);
 950                 pObj->SetPersistName(aObjName);
 951             }
 952             else
 953             {
 954                 // Das Einfuegen hat der Dialog schon gemacht
 955                 pObj->SetObjRef(xObj);
 956             }
 957
 958             Rectangle aRect = pObj->GetLogicRect();
 959
 960             if ( pObj->GetAspect() != embed::Aspects::MSOLE_ICON )
 961             {
 962                 awt::Size aSz;
 963                 aSz.Width = aRect.GetWidth();
 964                 aSz.Height = aRect.GetHeight();
 965                 xObj->setVisualAreaSize( pObj->GetAspect(), aSz );
 966             }
 967
 968             GetViewShellBase().SetVerbs( xObj->getSupportedVerbs() );
 969
 970             nVerb = SVVERB_SHOW;
 971         }
 972         else
 973         {
 974             aErrCode = ERRCODE_SFX_OLEGENERAL;
 975         }
 976     }
 977
 978     if( aErrCode == 0 )
 979     {
 980         ::sd::View* pView = GetView();
 981
 982         if (pView->IsTextEdit())
 983         {
 984             pView->SdrEndTextEdit();
 985         }
 986
 987         SfxInPlaceClient* pSdClient =
 988             static_cast<Client*>(pViewShell->FindIPClient(
 989                 pObj->GetObjRef(), GetActiveWindow()));
 990
 991         if ( !pSdClient )
 992         {
 993             pSdClient = new Client(pObj, this, GetActiveWindow());
 994         }
 995
 996         Rectangle aRect = pObj->GetLogicRect();
 997         Size aDrawSize = aRect.GetSize();
 998
 999         MapMode aMapMode( GetDoc()->GetScaleUnit() );
1000         Size aObjAreaSize = pObj->GetOrigObjSize( &aMapMode );
1001         if( pObj->IsChart() ) //charts never should be stretched see #i84323# for example
1002             aObjAreaSize = aDrawSize;
1003
1004         Fraction aScaleWidth (aDrawSize.Width(),  aObjAreaSize.Width() );
1005         Fraction aScaleHeight(aDrawSize.Height(), aObjAreaSize.Height() );
1006         aScaleWidth.ReduceInaccurate(10);       // kompatibel zum SdrOle2Obj
1007         aScaleHeight.ReduceInaccurate(10);
1008         pSdClient->SetSizeScale(aScaleWidth, aScaleHeight);
1009
1010         // sichtbarer Ausschnitt wird nur inplace veraendert!
1011         aRect.SetSize(aObjAreaSize);
1012         // the object area size must be set after scaling, since it triggers the resizing
1013         pSdClient->SetObjArea(aRect);
1014
1015         if( bChangeDefaultsForChart && xObj.is())
1016         {
1017             AdaptDefaultsForChart( xObj );
1018         }
1019
1020         pSdClient->DoVerb(nVerb);   // ErrCode wird ggf. vom Sfx ausgegeben
1021         pViewShell->GetViewFrame()->GetBindings().Invalidate(
1022             SID_NAVIGATOR_STATE, TRUE, FALSE);
1023     }
1024
1025     GetDocSh()->SetWaitCursor( FALSE );
1026
1027     if (aErrCode != 0 && !bAbort)
1028     {
1029         ErrorHandler::HandleError(* new StringErrorInfo(aErrCode, String() ) );
1030     }
1031
1032     return aErrCode == 0;
1033 }
1034
1035 /*************************************************************************
1036 |*
1037 |* umschliessendes Rechteck aller (Split-)Fenster zurueckgeben.
1038 |*
1039 \************************************************************************/
1040
1041 const Rectangle& ViewShell::GetAllWindowRect()
1042 {
1043     maAllWindowRectangle.SetPos(
1044         mpContentWindow->OutputToScreenPixel(Point(0,0)));
1045     return maAllWindowRectangle;
1046 }
1047
1048 /*************************************************************************
1049 |*
1050 |* Read user data
1051 |*
1052 \************************************************************************/
1053 void ViewShell::ReadUserData(const String&)
1054 {
1055     // Auf an FrameView gemerkte VisArea zoomen
1056     GetViewShell()->GetViewFrame()->GetDispatcher()->Execute(SID_SIZE_VISAREA,
1057         SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD);
1058 }
1059
1060 /*************************************************************************
1061 |*
1062 |* Write user data
1063 |*
1064 \************************************************************************/
1065
1066 void ViewShell::WriteUserData(String&)
1067 {
1068     // Das Schreiben unserer Daten erfolgt stets in WriteFrameViewData()
1069     WriteFrameViewData();
1070 }
1071
1072
1073 /*************************************************************************
1074 |*
1075 |* Lineale ein- / ausschalten
1076 |*
1077 \************************************************************************/
1078
1079 void ViewShell::SetRuler(BOOL bRuler)
1080 {
1081     mbHasRulers = ( bRuler && !GetDocSh()->IsPreview() ); // no rulers on preview mode
1082
1083     if (mpHorizontalRuler.get() != NULL)
1084     {
1085         if (mbHasRulers)
1086         {
1087             mpHorizontalRuler->Show();
1088         }
1089         else
1090         {
1091             mpHorizontalRuler->Hide();
1092         }
1093     }
1094
1095     if (mpVerticalRuler.get() != NULL)
1096     {
1097         if (mbHasRulers)
1098         {
1099             mpVerticalRuler->Show();
1100         }
1101         else
1102         {
1103             mpVerticalRuler->Hide();
1104         }
1105     }
1106
1107     OSL_ASSERT(GetViewShell()!=NULL);
1108     if (IsMainViewShell())
1109         GetViewShell()->InvalidateBorder();
1110 }
1111
1112 /*************************************************************************
1113 |*
1114 |* AcceptDrop
1115 |*
1116 \************************************************************************/
1117
1118 sal_Int8 ViewShell::AcceptDrop (
1119     const AcceptDropEvent& rEvt,
1120     DropTargetHelper& rTargetHelper,
1121     ::sd::Window* pTargetWindow,
1122     USHORT nPage,
1123     USHORT nLayer)
1124 {
1125     ::sd::View* pView = GetView();
1126     return( pView ? pView->AcceptDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE );
1127 }
1128
1129 /*************************************************************************
1130 |*
1131 |* ExecuteDrop
1132 |*
1133 \************************************************************************/
1134
1135 sal_Int8 ViewShell::ExecuteDrop (
1136     const ExecuteDropEvent& rEvt,
1137     DropTargetHelper& rTargetHelper,
1138     ::sd::Window* pTargetWindow,
1139     USHORT nPage,
1140     USHORT nLayer)
1141 {
1142     ::sd::View* pView = GetView();
1143     return( pView ? pView->ExecuteDrop( rEvt, rTargetHelper, pTargetWindow, nPage, nLayer ) : DND_ACTION_NONE );
1144 }
1145
1146 #ifdef _MSC_VER
1147 #pragma optimize ( "", on )
1148 #endif
1149
1150 void ViewShell::WriteUserDataSequence ( ::com::sun::star::uno::Sequence <
1151     ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse)
1152 {
1153     const sal_Int32 nIndex = rSequence.getLength();
1154     rSequence.realloc( nIndex + 1 );
1155
1156     OSL_ASSERT (GetViewShell()!=NULL);
1157     // Get the view id from the view shell in the center pane.  This will
1158     // usually be the called view shell, but to be on the safe side we call
1159     // the main view shell explicitly.
1160     sal_uInt16 nViewID (IMPRESS_FACTORY_ID);
1161     if (GetViewShellBase().GetMainViewShell().get() != NULL)
1162         nViewID = GetViewShellBase().GetMainViewShell()->mpImpl->GetViewId();
1163     rSequence[nIndex].Name = rtl::OUString (
1164         RTL_CONSTASCII_USTRINGPARAM( sUNO_View_ViewId ) );
1165     rtl::OUStringBuffer sBuffer (
1166         rtl::OUString(RTL_CONSTASCII_USTRINGPARAM( "view" ) ) );
1167     sBuffer.append( static_cast<sal_Int32>(nViewID));
1168     rSequence[nIndex].Value <<= sBuffer.makeStringAndClear();
1169
1170     mpFrameView->WriteUserDataSequence( rSequence, bBrowse );
1171 }
1172
1173
1174 void ViewShell::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse )
1175 {
1176     mpFrameView->ReadUserDataSequence( rSequence, bBrowse );
1177 }
1178
1179 void ViewShell::VisAreaChanged(const Rectangle& rRect)
1180 {
1181     OSL_ASSERT (GetViewShell()!=NULL);
1182     GetViewShell()->VisAreaChanged(rRect);
1183 }
1184
1185 void ViewShell::SetWinViewPos(const Point& rWinPos, bool bUpdate)
1186 {
1187     if (mpContentWindow.get() != NULL)
1188     {
1189         mpContentWindow->SetWinViewPos(rWinPos);
1190
1191         if ( bUpdate )
1192         {
1193             mpContentWindow->UpdateMapOrigin();
1194             mpContentWindow->Invalidate();
1195         }
1196     }
1197
1198     if (mbHasRulers)
1199     {
1200         UpdateHRuler();
1201         UpdateVRuler();
1202     }
1203
1204     UpdateScrollBars();
1205
1206     Size aVisSizePixel = GetActiveWindow()->GetOutputSizePixel();
1207     Rectangle aVisAreaWin = GetActiveWindow()->PixelToLogic( Rectangle( Point(0,0), aVisSizePixel) );
1208     VisAreaChanged(aVisAreaWin);
1209
1210     ::sd::View* pView = GetView();
1211     if (pView)
1212     {
1213         pView->VisAreaChanged(GetActiveWindow());
1214     }
1215 }
1216
1217 Point ViewShell::GetWinViewPos() const
1218 {
1219     return mpContentWindow->GetWinViewPos();
1220 }
1221
1222 Point ViewShell::GetViewOrigin() const
1223 {
1224     return mpContentWindow->GetViewOrigin();
1225 }
1226
1227 void ViewShell::AdaptDefaultsForChart(
1228     const uno::Reference < embed::XEmbeddedObject > & xEmbObj )
1229 {
1230     if( xEmbObj.is())
1231     {
1232         uno::Reference< chart2::XChartDocument > xChartDoc( xEmbObj->getComponent(), uno::UNO_QUERY );
1233         OSL_ENSURE( xChartDoc.is(), "Trying to set chart property to non-chart OLE" );
1234         if( !xChartDoc.is())
1235             return;
1236
1237         try
1238         {
1239             // set background to transparent (none)
1240             uno::Reference< beans::XPropertySet > xPageProp( xChartDoc->getPageBackground());
1241             if( xPageProp.is())
1242                 xPageProp->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("FillStyle")),
1243                                              uno::makeAny( drawing::FillStyle_NONE ));
1244             // set no border
1245             if( xPageProp.is())
1246                 xPageProp->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("LineStyle")),
1247                                              uno::makeAny( drawing::LineStyle_NONE ));
1248         }
1249         catch( const uno::Exception & )
1250         {
1251             OSL_ENSURE( false, "Exception caught in AdaptDefaultsForChart" );
1252         }
1253     }
1254 }
1255
1256 } // end of namespace sd