sd/source/ui/view/frmview.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: frmview.cxx,v $
  10  * $Revision: 1.38.108.1 $
  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
  34 #include "FrameView.hxx"
  35
  36 #ifndef _SVXIDS_HRC
  37 #include <svx/svxids.hrc>
  38 #endif
  39 #include <sfx2/topfrm.hxx>
  40 #include <com/sun/star/awt/Rectangle.hpp>
  41 #include <com/sun/star/drawing/framework/ResourceId.hpp>
  42 #include <rtl/ustrbuf.hxx>
  43 #include "unokywds.hxx"
  44
  45 #include <vector>
  46 #include "ViewShell.hxx"
  47 #include "drawdoc.hxx"
  48 #include "DrawDocShell.hxx"
  49 #include "optsitem.hxx"
  50 #include "ViewShellBase.hxx"
  51 #include "DrawViewShell.hxx"
  52 #include "OutlineViewShell.hxx"
  53 #include "app.hxx"
  54 #include "sdresid.hxx"
  55 #include "pres.hxx"
  56 #include "glob.hrc"
  57 #include "sdiocmpt.hxx"
  58 #include "framework/FrameworkHelper.hxx"
  59 #include <comphelper/processfactory.hxx>
  60
  61 using namespace ::com::sun::star;
  62 using namespace ::com::sun::star::uno;
  63 using namespace ::com::sun::star::beans;
  64 using namespace ::std;
  65 using ::rtl::OUString;
  66
  67 namespace sd {
  68
  69 /*************************************************************************
  70 |*
  71 |* Ctor
  72 |*
  73 \************************************************************************/
  74
  75 FrameView::FrameView(SdDrawDocument* pDrawDoc, FrameView* pFrameView /* = NULK */)
  76   : SdrView(pDrawDoc, (OutputDevice*) NULL),
  77     mnRefCount(0),
  78     mnPresViewShellId(SID_VIEWSHELL0),
  79     mnSlotId(SID_OBJECT_SELECT),
  80     mbIsNavigatorShowingAllShapes(false)
  81 {
  82     EndListening(*pDrawDoc);
  83
  84     EnableExtendedKeyInputDispatcher(FALSE);
  85     EnableExtendedMouseEventDispatcher(FALSE);
  86     EnableExtendedCommandEventDispatcher(FALSE);
  87
  88     SetGridFront( FALSE );
  89     SetHlplFront( FALSE );
  90     SetOConSnap( FALSE );
  91     SetFrameDragSingles( TRUE );
  92     SetSlidesPerRow(4);
  93
  94     if( NULL == pFrameView )
  95     {
  96         DrawDocShell* pDocShell = pDrawDoc->GetDocSh();
  97
  98         if ( pDocShell )
  99         {
 100             /**********************************************************************
 101             * Das Dokument wurde geladen, ist eine FrameView vorhanden?
 102             **********************************************************************/
 103             ULONG nSdViewShellCount = 0;
 104             ViewShellBase* pBase = NULL;
 105             SfxViewShell* pSfxViewSh = NULL;
 106             SfxViewFrame* pSfxViewFrame = SfxViewFrame::GetFirst(pDocShell,
 107                                                                  TYPE(SfxTopViewFrame));
 108
 109             while (pSfxViewFrame)
 110             {
 111                 // Count the FrameViews and remember the type of the main
 112                 // view shell.
 113                 pSfxViewSh = pSfxViewFrame->GetViewShell();
 114                 pBase = PTR_CAST(ViewShellBase, pSfxViewSh );
 115
 116                 if (pBase != NULL)
 117                 {
 118                     nSdViewShellCount++;
 119
 120                     ::rtl::OUString sViewURL;
 121                     Reference<drawing::framework::XView> xView (
 122                         framework::FrameworkHelper::Instance(*pBase)->GetView(
 123                             drawing::framework::ResourceId::create(
 124                                 ::comphelper::getProcessComponentContext(),
 125                                 framework::FrameworkHelper::msCenterPaneURL)));
 126                     if (xView.is())
 127                         sViewURL = xView->getResourceId()->getResourceURL();
 128
 129                     switch (framework::FrameworkHelper::GetViewId(sViewURL))
 130                     {
 131                         default:
 132 //                        case ViewShell::ST_IMPRESS:
 133 //                            case ViewShell::ST_NOTES:
 134 //                        case ViewShell::ST_HANDOUT:
 135                             mnPresViewShellId = SID_VIEWSHELL0;
 136                             break;
 137
 138                         case ViewShell::ST_SLIDE_SORTER:
 139                             mnPresViewShellId = SID_VIEWSHELL1;
 140                             break;
 141
 142                         case ViewShell::ST_OUTLINE:
 143                             mnPresViewShellId = SID_VIEWSHELL2;
 144                             break;
 145                     }
 146                 }
 147
 148                 pSfxViewFrame = SfxViewFrame::GetNext(*pSfxViewFrame, pDocShell,
 149                                                       TYPE(SfxTopViewFrame));
 150             }
 151
 152             SdDrawDocument* pDoc = pDocShell->GetDoc();
 153             pFrameView = pDoc->GetFrameView(nSdViewShellCount);
 154         }
 155     }
 156
 157     if (pFrameView)
 158     {
 159         /**********************************************************************
 160         * FrameView mit der FrameView der DocShell initialisieren
 161         **********************************************************************/
 162         SetRuler( pFrameView->HasRuler() );
 163         SetGridCoarse( pFrameView->GetGridCoarse() );
 164         SetGridFine( pFrameView->GetGridFine() );
 165         SetSnapGridWidth(pFrameView->GetSnapGridWidthX(), pFrameView->GetSnapGridWidthY());
 166         SetGridVisible( pFrameView->IsGridVisible() );
 167         SetGridFront( pFrameView->IsGridFront() );
 168         SetSnapAngle( pFrameView->GetSnapAngle() );
 169         SetGridSnap( pFrameView->IsGridSnap() );
 170         SetBordSnap( pFrameView->IsBordSnap() );
 171         SetHlplSnap( pFrameView->IsHlplSnap() );
 172         SetOFrmSnap( pFrameView->IsOFrmSnap() );
 173         SetOPntSnap( pFrameView->IsOPntSnap() );
 174         SetOConSnap( pFrameView->IsOConSnap() );
 175         SetHlplVisible( pFrameView->IsHlplVisible() );
 176         SetDragStripes( pFrameView->IsDragStripes() );
 177         SetPlusHandlesAlwaysVisible( pFrameView->IsPlusHandlesAlwaysVisible() );
 178         SetFrameDragSingles( pFrameView->IsFrameDragSingles() );
 179         SetSnapMagneticPixel( pFrameView->GetSnapMagneticPixel() );
 180         SetMarkedHitMovesAlways( pFrameView->IsMarkedHitMovesAlways() );
 181         SetMoveOnlyDragging( pFrameView->IsMoveOnlyDragging() );
 182         SetCrookNoContortion( pFrameView->IsCrookNoContortion() );
 183         SetSlantButShear( pFrameView->IsSlantButShear() );
 184         SetNoDragXorPolys( pFrameView->IsNoDragXorPolys() );
 185         SetAngleSnapEnabled( pFrameView->IsAngleSnapEnabled() );
 186         SetBigOrtho( pFrameView->IsBigOrtho() );
 187         SetOrtho( pFrameView->IsOrtho() );
 188         SetEliminatePolyPointLimitAngle( pFrameView->GetEliminatePolyPointLimitAngle() );
 189         SetEliminatePolyPoints( pFrameView->IsEliminatePolyPoints() );
 190 // #110094#-7
 191 //              SetMasterPagePaintCaching( pFrameView->IsMasterPagePaintCaching() );
 192         SetDesignMode( pFrameView->IsDesignMode() );
 193
 194         SetSolidMarkHdl( pFrameView->IsSolidMarkHdl() );
 195         SetSolidDragging( pFrameView->IsSolidDragging() );
 196
 197         maVisibleLayers = pFrameView->GetVisibleLayers();
 198         maPrintableLayers = pFrameView->GetPrintableLayers();
 199         maLockedLayers = pFrameView->GetLockedLayers();
 200         maStandardHelpLines = pFrameView->GetStandardHelpLines();
 201         maNotesHelpLines = pFrameView->GetNotesHelpLines();
 202         maHandoutHelpLines = pFrameView->GetHandoutHelpLines();
 203         SetActiveLayer( pFrameView->GetActiveLayer() );
 204         mbNoColors = pFrameView->IsNoColors();
 205         mbNoAttribs = pFrameView->IsNoAttribs() ;
 206         maVisArea = pFrameView->GetVisArea();
 207         mePageKind = pFrameView->GetPageKind();
 208         mePageKindOnLoad = pFrameView->GetPageKindOnLoad();
 209         mnSelectedPage = pFrameView->GetSelectedPage();
 210         mnSelectedPageOnLoad = pFrameView->GetSelectedPageOnLoad();
 211         meStandardEditMode = pFrameView->GetViewShEditMode(PK_STANDARD);
 212         meNotesEditMode = pFrameView->GetViewShEditMode(PK_NOTES);
 213         meHandoutEditMode = pFrameView->GetViewShEditMode(PK_HANDOUT);
 214         SetViewShEditModeOnLoad(pFrameView->GetViewShEditModeOnLoad());
 215         mbLayerMode = pFrameView->IsLayerMode();
 216         mbQuickEdit = pFrameView->IsQuickEdit();
 217
 218         // #i26631#
 219         SetMasterPagePaintCaching( pFrameView->IsMasterPagePaintCaching() );
 220
 221         SetDragWithCopy( pFrameView->IsDragWithCopy() );
 222         mbBigHandles             = pFrameView->IsBigHandles();
 223         mbDoubleClickTextEdit = pFrameView->IsDoubleClickTextEdit();
 224         mbClickChangeRotation = pFrameView->IsClickChangeRotation();
 225         mnSlidesPerRow = pFrameView->GetSlidesPerRow();
 226         mnDrawMode = pFrameView->GetDrawMode();
 227         mnTabCtrlPercent = pFrameView->GetTabCtrlPercent();
 228         mbIsNavigatorShowingAllShapes = pFrameView->IsNavigatorShowingAllShapes();
 229         SetPreviousViewShellType (pFrameView->GetPreviousViewShellType());
 230         SetViewShellTypeOnLoad (pFrameView->GetViewShellTypeOnLoad());
 231     }
 232     else
 233     {
 234         /**********************************************************************
 235         * FrameView mit den Applikationsdaten initialisieren
 236         **********************************************************************/
 237         maVisibleLayers.SetAll();
 238         maPrintableLayers.SetAll();
 239         SetGridCoarse( Size( 1000, 1000 ) );
 240         SetSnapGridWidth(Fraction(1000, 1), Fraction(1000, 1));
 241         SetActiveLayer( String( SdResId(STR_LAYER_LAYOUT) ) );
 242         mbNoColors = TRUE;
 243         mbNoAttribs = FALSE;
 244         maVisArea = Rectangle( Point(), Size(0, 0) );
 245         mePageKind = PK_STANDARD;
 246         mePageKindOnLoad = PK_STANDARD;
 247         mnSelectedPage = 0;
 248         mnSelectedPageOnLoad = 0;
 249         meStandardEditMode = EM_PAGE;
 250         meNotesEditMode = EM_PAGE;
 251         meHandoutEditMode = EM_MASTERPAGE;
 252         SetViewShEditModeOnLoad(EM_PAGE);
 253         mbLayerMode = FALSE;
 254         SetEliminatePolyPoints(FALSE);
 255         mbBigHandles = FALSE;
 256         mbDoubleClickTextEdit = FALSE;
 257         mbClickChangeRotation = FALSE;
 258         mnSlidesPerRow = 4;
 259
 260         {
 261             bool bUseContrast = Application::GetSettings().GetStyleSettings().GetHighContrastMode();
 262             mnDrawMode = bUseContrast ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR;
 263         }
 264         mnTabCtrlPercent = 0.0;
 265         mbIsNavigatorShowingAllShapes = false;
 266         SetPreviousViewShellType (ViewShell::ST_NONE);
 267         SetViewShellTypeOnLoad (ViewShell::ST_IMPRESS);
 268
 269         // get default for design mode
 270         sal_Bool bInitDesignMode = pDrawDoc->GetOpenInDesignMode();
 271         if( pDrawDoc->OpenInDesignModeIsDefaulted() )
 272         {
 273             bInitDesignMode = sal_True;
 274         }
 275
 276         SfxObjectShell* pObjShell = pDrawDoc->GetObjectShell();
 277         if( pObjShell && pObjShell->IsReadOnly() )
 278             bInitDesignMode = sal_False;
 279         SetDesignMode( bInitDesignMode );
 280
 281         Update( SD_MOD()->GetSdOptions(pDrawDoc->GetDocumentType()) );
 282     }
 283
 284 }
 285
 286 /*************************************************************************
 287 |*
 288 |* Dtor
 289 |*
 290 \************************************************************************/
 291
 292 FrameView::~FrameView()
 293 {
 294 }
 295
 296
 297 /*************************************************************************
 298 |*
 299 |* Verbindung herstellen
 300 |*
 301 \************************************************************************/
 302
 303 void FrameView::Connect()
 304 {
 305     mnRefCount++;
 306 }
 307
 308
 309 /*************************************************************************
 310 |*
 311 |* Verbindung loesen
 312 |*
 313 \************************************************************************/
 314
 315 void FrameView::Disconnect()
 316 {
 317     if (mnRefCount > 0)
 318     {
 319         mnRefCount--;
 320     }
 321
 322     if (mnRefCount == 0)
 323     {
 324         delete this;
 325     }
 326 }
 327
 328 /*************************************************************************
 329 |*
 330 |* Update mit Daten der SdOptions
 331 |*
 332 \************************************************************************/
 333
 334 void FrameView::Update(SdOptions* pOptions)
 335 {
 336     if (pOptions)
 337     {
 338         mbRuler = pOptions->IsRulerVisible();
 339         SetGridVisible( pOptions->IsGridVisible() );
 340         SetSnapAngle( pOptions->GetAngle() );
 341         SetGridSnap( pOptions->IsUseGridSnap() );
 342         SetBordSnap( pOptions->IsSnapBorder()  );
 343         SetHlplSnap( pOptions->IsSnapHelplines() );
 344         SetOFrmSnap( pOptions->IsSnapFrame() );
 345         SetOPntSnap( pOptions->IsSnapPoints() );
 346         SetHlplVisible( pOptions->IsHelplines() );
 347         SetDragStripes( pOptions->IsDragStripes() );
 348         SetPlusHandlesAlwaysVisible( pOptions->IsHandlesBezier() );
 349         SetSnapMagneticPixel( pOptions->GetSnapArea() );
 350         SetMarkedHitMovesAlways( pOptions->IsMarkedHitMovesAlways() );
 351         SetMoveOnlyDragging( pOptions->IsMoveOnlyDragging() );
 352         SetSlantButShear( pOptions->IsMoveOnlyDragging() );
 353         SetNoDragXorPolys ( !pOptions->IsMoveOutline() );
 354         SetCrookNoContortion( pOptions->IsCrookNoContortion() );
 355         SetAngleSnapEnabled( pOptions->IsRotate() );
 356         SetBigOrtho( pOptions->IsBigOrtho() );
 357         SetOrtho( pOptions->IsOrtho() );
 358         SetEliminatePolyPointLimitAngle( pOptions->GetEliminatePolyPointLimitAngle() );
 359 // #110094#-7
 360 //              SetMasterPagePaintCaching( pOptions->IsMasterPagePaintCaching() );
 361         GetModel()->SetPickThroughTransparentTextFrames( pOptions->IsPickThrough() );
 362
 363         SetSolidMarkHdl( pOptions->IsSolidMarkHdl() );
 364         SetSolidDragging( pOptions->IsSolidDragging() );
 365
 366         SetGridCoarse( Size( pOptions->GetFldDrawX(), pOptions->GetFldDrawY() ) );
 367         SetGridFine( Size( pOptions->GetFldDivisionX(), pOptions->GetFldDivisionY() ) );
 368         Fraction aFractX(pOptions->GetFldDrawX(), pOptions->GetFldDrawX() / ( pOptions->GetFldDivisionX() ? pOptions->GetFldDivisionX() : 1 ));
 369         Fraction aFractY(pOptions->GetFldDrawY(), pOptions->GetFldDrawY() / ( pOptions->GetFldDivisionY() ? pOptions->GetFldDivisionY() : 1 ));
 370         SetSnapGridWidth(aFractX, aFractY);
 371         SetQuickEdit(pOptions->IsQuickEdit());
 372
 373         // #i26631#
 374         SetMasterPagePaintCaching( pOptions->IsMasterPagePaintCaching() );
 375
 376         SetDragWithCopy(pOptions->IsDragWithCopy());
 377         SetBigHandles( pOptions->IsBigHandles() );
 378         SetDoubleClickTextEdit( pOptions->IsDoubleClickTextEdit() );
 379         SetClickChangeRotation( pOptions->IsClickChangeRotation() );
 380     }
 381 }
 382
 383
 384 /*************************************************************************
 385 |*
 386 |* EditMode (Page oder MasterPage) des Arbeitsmodus setzen
 387 |*
 388 \************************************************************************/
 389
 390 void FrameView::SetViewShEditMode(EditMode eMode, PageKind eKind)
 391 {
 392     if (eKind == PK_STANDARD)
 393     {
 394         meStandardEditMode = eMode;
 395     }
 396     else if (eKind == PK_NOTES)
 397     {
 398         meNotesEditMode = eMode;
 399     }
 400     else if (eKind == PK_HANDOUT)
 401     {
 402         meHandoutEditMode = eMode;
 403     }
 404 }
 405
 406
 407 /*************************************************************************
 408 |*
 409 |* EditMode (Page oder MasterPage) des Arbeitsmodus zurueckgeben
 410 |*
 411 \************************************************************************/
 412
 413 EditMode FrameView::GetViewShEditMode(PageKind eKind)
 414 {
 415     EditMode eMode = EM_PAGE;
 416
 417     if (eKind == PK_STANDARD)
 418     {
 419         eMode = meStandardEditMode;
 420     }
 421     else if (eKind == PK_NOTES)
 422     {
 423         eMode = meNotesEditMode;
 424     }
 425     else if (eKind == PK_HANDOUT)
 426     {
 427         eMode = meHandoutEditMode;
 428     }
 429
 430     return (eMode);
 431 }
 432
 433
 434
 435
 436 void FrameView::SetViewShEditModeOnLoad (EditMode eMode)
 437 {
 438     meEditModeOnLoad = eMode;
 439 }
 440
 441
 442
 443
 444 EditMode FrameView::GetViewShEditModeOnLoad (void) const
 445 {
 446     return meEditModeOnLoad;
 447 }
 448
 449
 450
 451
 452 static OUString createHelpLinesString( const SdrHelpLineList& rHelpLines )
 453 {
 454     ::rtl::OUStringBuffer aLines;
 455
 456     const USHORT nCount = rHelpLines.GetCount();
 457     for( USHORT nHlpLine = 0; nHlpLine < nCount; nHlpLine++ )
 458     {
 459         const SdrHelpLine& rHelpLine = rHelpLines[nHlpLine];
 460         const Point& rPos = rHelpLine.GetPos();
 461
 462         switch( rHelpLine.GetKind() )
 463         {
 464             case SDRHELPLINE_POINT:
 465                 aLines.append( (sal_Unicode)'P' );
 466                 aLines.append( (sal_Int32)rPos.X() );
 467                 aLines.append( (sal_Unicode)',' );
 468                 aLines.append( (sal_Int32)rPos.Y() );
 469                 break;
 470             case SDRHELPLINE_VERTICAL:
 471                 aLines.append( (sal_Unicode)'V' );
 472                 aLines.append( (sal_Int32)rPos.X() );
 473                 break;
 474             case SDRHELPLINE_HORIZONTAL:
 475                 aLines.append( (sal_Unicode)'H' );
 476                 aLines.append( (sal_Int32)rPos.Y() );
 477                 break;
 478             default:
 479                 DBG_ERROR( "Unsupported helpline Kind!" );
 480         }
 481     }
 482
 483     return aLines.makeStringAndClear();
 484 }
 485
 486 #define addValue( n, v ) push_back( std::pair< OUString, Any >( OUString( RTL_CONSTASCII_USTRINGPARAM( n ) ), v ) )
 487 void FrameView::WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rValues, sal_Bool )
 488 {
 489     std::vector< std::pair< OUString, Any > > aUserData;
 490
 491     aUserData.addValue( sUNO_View_GridIsVisible, makeAny( (sal_Bool)IsGridVisible() ) );
 492     aUserData.addValue( sUNO_View_GridIsFront, makeAny( (sal_Bool)IsGridFront() ) );
 493     aUserData.addValue( sUNO_View_IsSnapToGrid, makeAny( (sal_Bool)IsGridSnap() ) );
 494     aUserData.addValue( sUNO_View_IsSnapToPageMargins, makeAny( (sal_Bool)IsBordSnap() ) );
 495     aUserData.addValue( sUNO_View_IsSnapToSnapLines, makeAny( (sal_Bool)IsHlplSnap() ) );
 496     aUserData.addValue( sUNO_View_IsSnapToObjectFrame, makeAny( (sal_Bool)IsOFrmSnap() ) );
 497     aUserData.addValue( sUNO_View_IsSnapToObjectPoints, makeAny( (sal_Bool)IsOPntSnap() ) );
 498
 499 //      pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsSnapLinesVisible ) );
 500 //      pValue->Value <<= (sal_Bool)IsHlplVisible();
 501 //  pValue++;nIndex++;
 502
 503 //      pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsDragStripes ) );
 504 //      pValue->Value <<= (sal_Bool)IsDragStripes();
 505 //  pValue++;nIndex++;
 506
 507     aUserData.addValue( sUNO_View_IsPlusHandlesAlwaysVisible, makeAny( (sal_Bool)IsPlusHandlesAlwaysVisible() ) );
 508     aUserData.addValue( sUNO_View_IsFrameDragSingles, makeAny( (sal_Bool)IsFrameDragSingles() ) );
 509
 510 //      pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsMarkedHitMovesAlways ) );
 511 //      pValue->Value <<= (sal_Bool)IsMarkedHitMovesAlways();
 512 //  pValue++;nIndex++;
 513
 514     aUserData.addValue( sUNO_View_EliminatePolyPointLimitAngle, makeAny( (sal_Int32)GetEliminatePolyPointLimitAngle() ) );
 515     aUserData.addValue( sUNO_View_IsEliminatePolyPoints, makeAny( (sal_Bool)IsEliminatePolyPoints() ) );
 516
 517 //      pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsLineDraft ) );
 518 //      pValue->Value <<= (sal_Bool)IsLineDraft();
 519 //  pValue++;nIndex++;
 520
 521 //      pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsFillDraft ) );
 522 //      pValue->Value <<= (sal_Bool)IsFillDraft();
 523 //  pValue++;nIndex++;
 524
 525 //      pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsTextDraft ) );
 526 //      pValue->Value <<= (sal_Bool)IsTextDraft();
 527 //  pValue++;nIndex++;
 528
 529 //      pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsGrafDraft ) );
 530 //      pValue->Value <<= (sal_Bool)IsGrafDraft();
 531 //  pValue++;nIndex++;
 532
 533     Any aAny;
 534     GetVisibleLayers().QueryValue( aAny );
 535     aUserData.addValue( sUNO_View_VisibleLayers, aAny );
 536
 537     GetPrintableLayers().QueryValue( aAny );
 538     aUserData.addValue( sUNO_View_PrintableLayers, aAny );
 539
 540     GetLockedLayers().QueryValue( aAny );
 541     aUserData.addValue( sUNO_View_LockedLayers, aAny );
 542
 543     aUserData.addValue( sUNO_View_NoAttribs, makeAny( (sal_Bool)IsNoAttribs() ) );
 544     aUserData.addValue( sUNO_View_NoColors, makeAny( (sal_Bool)IsNoColors() ) );
 545
 546     if( GetStandardHelpLines().GetCount() )
 547         aUserData.addValue( sUNO_View_SnapLinesDrawing, makeAny( createHelpLinesString( GetStandardHelpLines() ) ) );
 548
 549     if( GetNotesHelpLines().GetCount() )
 550         aUserData.addValue( sUNO_View_SnapLinesNotes, makeAny( createHelpLinesString( GetNotesHelpLines() ) ) );
 551
 552     if( GetHandoutHelpLines().GetCount() )
 553         aUserData.addValue( sUNO_View_SnapLinesHandout, makeAny( createHelpLinesString( GetHandoutHelpLines() ) ) );
 554
 555     aUserData.addValue( sUNO_View_RulerIsVisible, makeAny( (sal_Bool)HasRuler() ) );
 556     aUserData.addValue( sUNO_View_PageKind, makeAny( (sal_Int16)GetPageKind() ) );
 557     aUserData.addValue( sUNO_View_SelectedPage, makeAny( (sal_Int16)GetSelectedPage() ) );
 558     aUserData.addValue( sUNO_View_IsLayerMode, makeAny( (sal_Bool)IsLayerMode() ) );
 559
 560 //      pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsQuickEdit ) );
 561 //      pValue->Value <<= (sal_Bool)IsQuickEdit();
 562 //  pValue++;nIndex++;
 563
 564     aUserData.addValue( sUNO_View_IsBigHandles, makeAny( (sal_Bool)IsBigHandles() ) );
 565     aUserData.addValue( sUNO_View_IsDoubleClickTextEdit,  makeAny( (sal_Bool)IsDoubleClickTextEdit() ) );
 566     aUserData.addValue( sUNO_View_IsClickChangeRotation, makeAny( (sal_Bool)IsClickChangeRotation() ) );
 567
 568 //      pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsDragWithCopy ) );
 569 //      pValue->Value <<= (sal_Bool)IsDragWithCopy();
 570 //  pValue++;nIndex++;
 571
 572     aUserData.addValue( sUNO_View_SlidesPerRow, makeAny( (sal_Int16)GetSlidesPerRow() ) );
 573 /* #107128# Product managment decided to not make this persistent
 574     aUserData.addValue( sUNO_View_DrawMode, makeAny( (sal_Int32)GetDrawMode() ) );
 575     aUserData.addValue( sUNO_View_PreviewDrawMode, makeAny( (sal_Int32)GetPreviewDrawMode() ) );
 576 */
 577     aUserData.addValue( sUNO_View_EditModeStandard, makeAny( (sal_Int32)GetViewShEditMode( PK_STANDARD ) ) );
 578     aUserData.addValue( sUNO_View_EditModeNotes, makeAny( (sal_Int32)GetViewShEditMode( PK_NOTES ) ) );
 579     aUserData.addValue( sUNO_View_EditModeHandout, makeAny( (sal_Int32)GetViewShEditMode( PK_HANDOUT ) ) );
 580
 581     {
 582         const Rectangle aVisArea = GetVisArea();
 583
 584         aUserData.addValue( sUNO_View_VisibleAreaTop, makeAny( (sal_Int32)aVisArea.Top() ) );
 585         aUserData.addValue( sUNO_View_VisibleAreaLeft, makeAny( (sal_Int32)aVisArea.Left() ) );
 586         aUserData.addValue( sUNO_View_VisibleAreaWidth, makeAny( (sal_Int32)aVisArea.GetWidth() ) );
 587         aUserData.addValue( sUNO_View_VisibleAreaHeight, makeAny( (sal_Int32)aVisArea.GetHeight() ) );
 588     }
 589
 590     aUserData.addValue( sUNO_View_GridCoarseWidth, makeAny( (sal_Int32)GetGridCoarse().Width() ) );
 591     aUserData.addValue( sUNO_View_GridCoarseHeight, makeAny( (sal_Int32)GetGridCoarse().Height() ) );
 592     aUserData.addValue( sUNO_View_GridFineWidth, makeAny( (sal_Int32)GetGridFine().Width() ) );
 593     aUserData.addValue( sUNO_View_GridFineHeight, makeAny( (sal_Int32)GetGridFine().Height() ) );
 594     aUserData.addValue( sUNO_View_GridSnapWidthXNumerator, makeAny( (sal_Int32)GetSnapGridWidthX().GetNumerator() ) );
 595     aUserData.addValue( sUNO_View_GridSnapWidthXDenominator, makeAny( (sal_Int32)GetSnapGridWidthX().GetDenominator() ) );
 596     aUserData.addValue( sUNO_View_GridSnapWidthYNumerator, makeAny( (sal_Int32)GetSnapGridWidthY().GetNumerator() ) );
 597     aUserData.addValue( sUNO_View_GridSnapWidthYDenominator, makeAny( (sal_Int32)GetSnapGridWidthY().GetDenominator() ) );
 598     aUserData.addValue( sUNO_View_IsAngleSnapEnabled, makeAny( (sal_Bool)IsAngleSnapEnabled() ) );
 599     aUserData.addValue( sUNO_View_SnapAngle, makeAny( (sal_Int32)GetSnapAngle() ) );
 600
 601     const sal_Int32 nOldLength = rValues.getLength();
 602     rValues.realloc( nOldLength + aUserData.size() );
 603
 604     PropertyValue* pValue = &(rValues.getArray()[nOldLength]);
 605
 606     std::vector< std::pair< OUString, Any > >::iterator aIter( aUserData.begin() );
 607     for( ; aIter != aUserData.end(); aIter++, pValue++ )
 608     {
 609         pValue->Name = (*aIter).first;
 610         pValue->Value = (*aIter).second;
 611     }
 612 }
 613 #undef addValue
 614
 615 static void createHelpLinesFromString( const rtl::OUString& rLines, SdrHelpLineList& rHelpLines )
 616 {
 617     const sal_Unicode * pStr = rLines.getStr();
 618     SdrHelpLine aNewHelpLine;
 619     rtl::OUStringBuffer sBuffer;
 620
 621     while( *pStr )
 622     {
 623         Point aPoint;
 624
 625         switch( *pStr )
 626         {
 627         case (sal_Unicode)'P':
 628             aNewHelpLine.SetKind( SDRHELPLINE_POINT );
 629             break;
 630         case (sal_Unicode)'V':
 631             aNewHelpLine.SetKind( SDRHELPLINE_VERTICAL );
 632             break;
 633         case (sal_Unicode)'H':
 634             aNewHelpLine.SetKind( SDRHELPLINE_HORIZONTAL );
 635             break;
 636         default:
 637             DBG_ERROR( "syntax error in snap lines settings string" );
 638             return;
 639         }
 640
 641         pStr++;
 642
 643         while( (*pStr >= sal_Unicode('0') && *pStr <= sal_Unicode('9')) || (*pStr == '+') || (*pStr == '-') )
 644         {
 645             sBuffer.append( *pStr++ );
 646         }
 647
 648         sal_Int32 nValue = sBuffer.makeStringAndClear().toInt32();
 649
 650         if( aNewHelpLine.GetKind() == SDRHELPLINE_HORIZONTAL )
 651         {
 652             aPoint.Y() = nValue;
 653         }
 654         else
 655         {
 656             aPoint.X() = nValue;
 657
 658             if( aNewHelpLine.GetKind() == SDRHELPLINE_POINT )
 659             {
 660                 if( *pStr++ != ',' )
 661                     return;
 662
 663                 while( (*pStr >= sal_Unicode('0') && *pStr <= sal_Unicode('9')) || (*pStr == '+') || (*pStr == '-')  )
 664                 {
 665                     sBuffer.append( *pStr++ );
 666                 }
 667
 668                 aPoint.Y() = sBuffer.makeStringAndClear().toInt32();
 669
 670             }
 671         }
 672
 673         aNewHelpLine.SetPos( aPoint );
 674         rHelpLines.Insert( aNewHelpLine );
 675     }
 676 }
 677
 678 void FrameView::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool )
 679 {
 680     const sal_Int32 nLength = rSequence.getLength();
 681     if (nLength)
 682     {
 683         const bool bImpress = dynamic_cast< SdDrawDocument* >(GetModel())->GetDocumentType() == DOCUMENT_TYPE_IMPRESS;
 684
 685         sal_Bool bBool = sal_False;
 686         sal_Int32 nInt32 = 0;
 687         sal_Int16 nInt16 = 0;
 688         rtl::OUString aString;
 689
 690         sal_Int32 aSnapGridWidthXNum = GetSnapGridWidthX().GetNumerator();
 691         sal_Int32 aSnapGridWidthXDom = GetSnapGridWidthX().GetDenominator();
 692
 693         sal_Int32 aSnapGridWidthYNum = GetSnapGridWidthY().GetNumerator();
 694         sal_Int32 aSnapGridWidthYDom = GetSnapGridWidthY().GetDenominator();
 695
 696         EditMode eStandardEditMode;
 697         EditMode eNotesEditMode;
 698         EditMode eHandoutEditMode;
 699
 700         const com::sun::star::beans::PropertyValue *pValue = rSequence.getConstArray();
 701         for (sal_Int16 i = 0 ; i < nLength; i++, pValue++ )
 702         {
 703             if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_ViewId ) ) )
 704             {
 705             }
 706             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapLinesDrawing ) ) )
 707             {
 708                 if( pValue->Value >>= aString )
 709                 {
 710                     SdrHelpLineList aHelpLines;
 711                     createHelpLinesFromString( aString, aHelpLines );
 712                     SetStandardHelpLines( aHelpLines );
 713                 }
 714             }
 715             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapLinesNotes ) ) )
 716             {
 717                 if( pValue->Value >>= aString )
 718                 {
 719                     SdrHelpLineList aHelpLines;
 720                     createHelpLinesFromString( aString, aHelpLines );
 721                     SetNotesHelpLines( aHelpLines );
 722                 }
 723             }
 724             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapLinesHandout ) ) )
 725             {
 726                 if( pValue->Value >>= aString )
 727                 {
 728                     SdrHelpLineList aHelpLines;
 729                     createHelpLinesFromString( aString, aHelpLines );
 730                     SetHandoutHelpLines( aHelpLines );
 731                 }
 732             }
 733             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_RulerIsVisible ) ) )
 734             {
 735                 if( pValue->Value >>= bBool )
 736                 {
 737                     SetRuler( bBool );
 738                 }
 739             }
 740             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_PageKind ) ) )
 741             {
 742                 if( pValue->Value >>= nInt16 )
 743                 {
 744                     SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() );
 745                     if( pDoc && pDoc->GetDocSh() && ( SFX_CREATE_MODE_EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) )
 746                         SetPageKind( (PageKind)nInt16 );
 747
 748                     SetPageKindOnLoad( (PageKind)nInt16 );
 749                 }
 750             }
 751             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SelectedPage ) ) )
 752             {
 753                 if( pValue->Value >>= nInt16 )
 754                 {
 755                     SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() );
 756                     if( pDoc && pDoc->GetDocSh() && ( SFX_CREATE_MODE_EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) )
 757                         SetSelectedPage( (USHORT)nInt16 );
 758
 759                     SetSelectedPageOnLoad( (USHORT)nInt16 );
 760                 }
 761             }
 762             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsLayerMode ) ) )
 763             {
 764                 if( pValue->Value >>= bBool )
 765                 {
 766                     SetLayerMode( bBool );
 767                 }
 768             }
 769 /*                      else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsQuickEdit ) ) )
 770             {
 771                 if( pValue->Value >>= bBool )
 772                 {
 773                     SetQuickEdit( bBool );
 774                 }
 775             }
 776 */                      else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsBigHandles ) ) )
 777             {
 778                 if( pValue->Value >>= bBool )
 779                 {
 780                     SetBigHandles( bBool );
 781                 }
 782             }
 783             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsDoubleClickTextEdit ) ) )
 784             {
 785                 if( pValue->Value >>= bBool )
 786                 {
 787                     SetDoubleClickTextEdit( bBool );
 788                 }
 789             }
 790             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsClickChangeRotation ) ) )
 791             {
 792                 if( pValue->Value >>= bBool )
 793                 {
 794                     SetClickChangeRotation( bBool );
 795                 }
 796             }
 797 /*                      else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsDragWithCopy ) ) )
 798             {
 799                 if( pValue->Value >>= bBool )
 800                 {
 801                     SetDragWithCopy( bBool );
 802                 }
 803             }
 804 */                      else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SlidesPerRow ) ) )
 805             {
 806                 if( pValue->Value >>= nInt16 )
 807                 {
 808                     SetSlidesPerRow( (USHORT)nInt16 );
 809                 }
 810             }
 811 /* #107128# Product managment decided to not make this persistent
 812             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_DrawMode ) ) )
 813             {
 814                 if( pValue->Value >>= nInt32 )
 815                 {
 816                     const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
 817                     if( rStyleSettings.GetHighContrastMode() )
 818                         continue;
 819                     SetDrawMode( (ULONG)nInt32 );
 820                 }
 821             }
 822             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_PreviewDrawMode ) ) )
 823             {
 824                 if( pValue->Value >>= nInt32 )
 825                 {
 826                     const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
 827                     SvtAccessibilityOptions aAccOptions;
 828                     if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForPagePreviews() )
 829                         continue;
 830                     SetPreviewDrawMode( (ULONG)nInt32 );
 831                 }
 832             }
 833 */
 834             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EditModeStandard ) ) )
 835             {
 836                 if( pValue->Value >>= nInt32 )
 837                 {
 838                     SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() );
 839                     if( pDoc && pDoc->GetDocSh() && ( SFX_CREATE_MODE_EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) )
 840                         SetViewShEditMode( (EditMode)nInt32, PK_STANDARD );
 841                     eStandardEditMode = (EditMode)nInt32;
 842                 }
 843             }
 844             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EditModeNotes ) ) )
 845             {
 846                 if( pValue->Value >>= nInt32 )
 847                 {
 848                     SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() );
 849                     if( pDoc && pDoc->GetDocSh() && ( SFX_CREATE_MODE_EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) )
 850                         SetViewShEditMode( (EditMode)nInt32, PK_NOTES );
 851                     eNotesEditMode = (EditMode)nInt32;
 852                 }
 853             }
 854             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EditModeHandout ) ) )
 855             {
 856                 if( pValue->Value >>= nInt32 )
 857                 {
 858                     SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() );
 859                     if( pDoc && pDoc->GetDocSh() && ( SFX_CREATE_MODE_EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) )
 860                         SetViewShEditMode( (EditMode)nInt32, PK_HANDOUT );
 861                     eHandoutEditMode = (EditMode)nInt32;
 862                 }
 863             }
 864             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaTop ) ) )
 865             {
 866                 sal_Int32 nTop = 0;
 867                 if( pValue->Value >>= nTop )
 868                 {
 869                     Rectangle aVisArea( GetVisArea() );
 870                     aVisArea.nBottom += nTop - aVisArea.nTop;
 871                     aVisArea.nTop = nTop;
 872                     SetVisArea( aVisArea );
 873                 }
 874             }
 875             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaLeft ) ) )
 876             {
 877                 sal_Int32 nLeft = 0;
 878                 if( pValue->Value >>= nLeft )
 879                 {
 880                     Rectangle aVisArea( GetVisArea() );
 881                     aVisArea.nRight += nLeft - aVisArea.nLeft;
 882                     aVisArea.nLeft = nLeft;
 883                     SetVisArea( aVisArea );
 884                 }
 885             }
 886             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaWidth ) ) )
 887             {
 888                 sal_Int32 nWidth = 0;
 889                                 if( (pValue->Value >>= nWidth) && nWidth > 0 )
 890                 {
 891                     Rectangle aVisArea( GetVisArea() );
 892                     aVisArea.nRight = aVisArea.nLeft + nWidth - 1;
 893                     SetVisArea( aVisArea );
 894                 }
 895             }
 896             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaHeight ) ) )
 897             {
 898                 sal_Int32 nHeight = 0;
 899                                 if( (pValue->Value >>= nHeight) && nHeight > 0 )
 900                 {
 901                     Rectangle aVisArea( GetVisArea() );
 902                     aVisArea.nBottom = nHeight + aVisArea.nTop - 1;
 903                     SetVisArea( aVisArea );
 904                 }
 905             }
 906
 907             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridIsVisible ) ) )
 908             {
 909                 if( pValue->Value >>= bBool )
 910                 {
 911                     SetGridVisible( bBool );
 912                 }
 913             }
 914
 915             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToGrid ) ) )
 916             {
 917                 if( pValue->Value >>= bBool )
 918                 {
 919                     SetGridSnap( bBool );
 920                 }
 921             }
 922             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridIsFront ) ) )
 923             {
 924                 if( pValue->Value >>= bBool )
 925                 {
 926                     SetGridFront( bBool );
 927                 }
 928             }
 929             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToPageMargins ) ) )
 930             {
 931                 if( pValue->Value >>= bBool )
 932                 {
 933                     SetBordSnap( bBool );
 934                 }
 935             }
 936             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToSnapLines ) ) )
 937             {
 938                 if( pValue->Value >>= bBool )
 939                 {
 940                     SetHlplSnap( bBool );
 941                 }
 942             }
 943             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToObjectFrame ) ) )
 944             {
 945                 if( pValue->Value >>= bBool )
 946                 {
 947                     SetOFrmSnap( bBool );
 948                 }
 949             }
 950             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToObjectPoints ) ) )
 951             {
 952                 if( pValue->Value >>= bBool )
 953                 {
 954                     SetOPntSnap( bBool );
 955                 }
 956             }
 957 /*                      else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapLinesVisible ) ) )
 958             {
 959                 if( pValue->Value >>= bBool )
 960                 {
 961                     SetHlplVisible( bBool );
 962                 }
 963             }
 964             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsDragStripes ) ) )
 965             {
 966                 if( pValue->Value >>= bBool )
 967                 {
 968                     SetDragStripes( bBool );
 969                 }
 970             }
 971 */                      else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsPlusHandlesAlwaysVisible ) ) )
 972             {
 973                 if( pValue->Value >>= bBool )
 974                 {
 975                     SetPlusHandlesAlwaysVisible( bBool );
 976                 }
 977             }
 978             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsFrameDragSingles ) ) )
 979             {
 980                 if( pValue->Value >>= bBool )
 981                 {
 982                     SetFrameDragSingles( bBool );
 983                 }
 984             }
 985 /*                      else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsMarkedHitMovesAlways ) ) )
 986             {
 987                 if( pValue->Value >>= bBool )
 988                 {
 989                     SetMarkedHitMovesAlways( bBool );
 990                 }
 991             }
 992 */                      else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EliminatePolyPointLimitAngle ) ) )
 993             {
 994                 if( pValue->Value >>= nInt32 )
 995                 {
 996                     SetEliminatePolyPointLimitAngle( nInt32 );
 997                 }
 998             }
 999             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsEliminatePolyPoints ) ) )
1000             {
1001                 if( pValue->Value >>= bBool )
1002                 {
1003                     SetEliminatePolyPoints( bBool );
1004                 }
1005             }
1006 /*
1007             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsLineDraft ) ) )
1008             {
1009                 if( pValue->Value >>= bBool )
1010                 {
1011                     SetLineDraft( bBool );
1012                 }
1013             }
1014             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsFillDraft ) ) )
1015             {
1016                 if( pValue->Value >>= bBool )
1017                 {
1018                     SetFillDraft( bBool );
1019                 }
1020             }
1021             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsTextDraft ) ) )
1022             {
1023                 if( pValue->Value >>= bBool )
1024                 {
1025                     SetTextDraft( bBool );
1026                 }
1027             }
1028             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsGrafDraft ) ) )
1029             {
1030                 if( pValue->Value >>= bBool )
1031                 {
1032                     SetGrafDraft( bBool );
1033                 }
1034             }
1035 */
1036             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_ActiveLayer ) ) )
1037             {
1038                 if( pValue->Value >>= aString )
1039                 {
1040                     SetActiveLayer( aString );
1041                 }
1042             }
1043             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_NoAttribs ) ) )
1044             {
1045                 if( pValue->Value >>= bBool )
1046                 {
1047                     SetNoAttribs( bBool );
1048                 }
1049             }
1050             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_NoColors ) ) )
1051             {
1052                 if( pValue->Value >>= bBool )
1053                 {
1054                     SetNoColors( bBool );
1055                 }
1056             }
1057             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridCoarseWidth ) ) )
1058             {
1059                 if( pValue->Value >>= nInt32 )
1060                 {
1061                     const Size aCoarse( nInt32, GetGridCoarse().Height() );
1062                     SetGridCoarse( aCoarse );
1063                 }
1064             }
1065             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridCoarseHeight ) ) )
1066             {
1067                 if( pValue->Value >>= nInt32 )
1068                 {
1069                     const Size aCoarse( GetGridCoarse().Width(), nInt32 );
1070                     SetGridCoarse( aCoarse );
1071                 }
1072             }
1073             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridFineWidth ) ) )
1074             {
1075                 if( pValue->Value >>= nInt32 )
1076                 {
1077                     const Size aCoarse( nInt32, GetGridFine().Height() );
1078                     SetGridFine( aCoarse );
1079                 }
1080             }
1081             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridFineHeight ) ) )
1082             {
1083                 if( pValue->Value >>= nInt32 )
1084                 {
1085                     const Size aCoarse( GetGridFine().Width(), nInt32 );
1086                     SetGridFine( aCoarse );
1087                 }
1088             }
1089             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsAngleSnapEnabled ) ) )
1090             {
1091                 if( pValue->Value >>= bBool )
1092                 {
1093                     SetAngleSnapEnabled( bBool );
1094                 }
1095             }
1096             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapAngle ) ) )
1097             {
1098                 if( pValue->Value >>= nInt32 )
1099                 {
1100                     SetSnapAngle( nInt32 );
1101                 }
1102             }
1103             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthXNumerator ) ) )
1104             {
1105                 pValue->Value >>= aSnapGridWidthXNum;
1106             }
1107             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthXDenominator ) ) )
1108             {
1109                 pValue->Value >>= aSnapGridWidthXDom;
1110             }
1111             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthYNumerator ) ) )
1112             {
1113                 pValue->Value >>= aSnapGridWidthYNum;
1114             }
1115             else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthYDenominator ) ) )
1116             {
1117                 pValue->Value >>= aSnapGridWidthYDom;
1118             }
1119             else if (!bImpress && pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleLayers ) ) )
1120             {
1121                 SetOfByte aSetOfBytes;
1122                 aSetOfBytes.PutValue( pValue->Value );
1123                 SetVisibleLayers( aSetOfBytes );
1124             }
1125             else if (!bImpress && pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_PrintableLayers ) ) )
1126             {
1127                 SetOfByte aSetOfBytes;
1128                 aSetOfBytes.PutValue( pValue->Value );
1129                 SetPrintableLayers( aSetOfBytes );
1130             }
1131             else if (!bImpress && pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_LockedLayers ) ) )
1132             {
1133                 SetOfByte aSetOfBytes;
1134                 aSetOfBytes.PutValue( pValue->Value );
1135                 SetLockedLayers( aSetOfBytes );
1136             }
1137         }
1138
1139         switch (GetPageKindOnLoad())
1140         {
1141             case PK_STANDARD: SetViewShEditModeOnLoad(meStandardEditMode); break;
1142             case PK_NOTES: SetViewShEditModeOnLoad(meNotesEditMode); break;
1143             case PK_HANDOUT: SetViewShEditModeOnLoad(meHandoutEditMode); break;
1144             default: SetViewShEditModeOnLoad(EM_PAGE); break;
1145         }
1146
1147         const Fraction aSnapGridWidthX( aSnapGridWidthXNum, aSnapGridWidthXDom );
1148         const Fraction aSnapGridWidthY( aSnapGridWidthYNum, aSnapGridWidthYDom );
1149
1150         SetSnapGridWidth( aSnapGridWidthX, aSnapGridWidthY );
1151     }
1152 }
1153
1154
1155
1156
1157 void FrameView::SetPreviousViewShellType (ViewShell::ShellType eType)
1158 {
1159     mePreviousViewShellType = eType;
1160 }
1161
1162
1163
1164
1165 ViewShell::ShellType FrameView::GetPreviousViewShellType (void) const
1166 {
1167     return mePreviousViewShellType;
1168 }
1169
1170
1171
1172
1173 void FrameView::SetViewShellTypeOnLoad (ViewShell::ShellType eType)
1174 {
1175     meViewShellTypeOnLoad = eType;
1176 }
1177
1178
1179
1180
1181 ViewShell::ShellType FrameView::GetViewShellTypeOnLoad (void) const
1182 {
1183     return meViewShellTypeOnLoad;
1184 }
1185
1186
1187
1188
1189 void FrameView::SetSelectedPage(USHORT nPage)
1190 {
1191     mnSelectedPage = nPage;
1192 }
1193
1194
1195
1196
1197 USHORT FrameView::GetSelectedPage (void) const
1198 {
1199     return mnSelectedPage;
1200 }
1201
1202
1203
1204
1205 void FrameView::SetIsNavigatorShowingAllShapes (const bool bIsNavigatorShowingAllShapes)
1206 {
1207     mbIsNavigatorShowingAllShapes = bIsNavigatorShowingAllShapes;
1208 }
1209
1210
1211
1212
1213 bool FrameView::IsNavigatorShowingAllShapes (void) const
1214 {
1215     return mbIsNavigatorShowingAllShapes;
1216 }
1217
1218
1219 } // end of namespace sd