sd/source/ui/view/frmview.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "FrameView.hxx"
  21
  22 #include <svx/svxids.hrc>
  23 #include <com/sun/star/awt/Rectangle.hpp>
  24 #include <com/sun/star/drawing/framework/ResourceId.hpp>
  25 #include <rtl/ustrbuf.hxx>
  26 #include "unokywds.hxx"
  27 #include <vcl/settings.hxx>
  28
  29 #include <vector>
  30 #include "ViewShell.hxx"
  31 #include "drawdoc.hxx"
  32 #include "DrawDocShell.hxx"
  33 #include "optsitem.hxx"
  34 #include "ViewShellBase.hxx"
  35 #include "DrawViewShell.hxx"
  36 #include "OutlineViewShell.hxx"
  37 #include "sdmod.hxx"
  38 #include "sdresid.hxx"
  39 #include "pres.hxx"
  40 #include "glob.hrc"
  41 #include "sdiocmpt.hxx"
  42 #include "framework/FrameworkHelper.hxx"
  43 #include <comphelper/processfactory.hxx>
  44 #include <sfx2/viewfrm.hxx>
  45
  46 using namespace ::com::sun::star;
  47 using namespace ::com::sun::star::uno;
  48 using namespace ::com::sun::star::beans;
  49 using namespace ::std;
  50
  51 namespace sd {
  52
  53 FrameView::FrameView(SdDrawDocument* pDrawDoc, FrameView* pFrameView /* = NULK */)
  54   : SdrView(pDrawDoc, (OutputDevice*) NULL),
  55     mnRefCount(0),
  56     mnPresViewShellId(SID_VIEWSHELL0),
  57     mnSlotId(SID_OBJECT_SELECT),
  58     mbIsNavigatorShowingAllShapes(false)
  59 {
  60     EndListening(*pDrawDoc);
  61
  62     EnableExtendedKeyInputDispatcher(false);
  63     EnableExtendedMouseEventDispatcher(false);
  64     EnableExtendedCommandEventDispatcher(false);
  65
  66     SetGridFront( false );
  67     SetHlplFront( false );
  68     SetOConSnap( false );
  69     SetFrameDragSingles( true );
  70     SetSlidesPerRow(4);
  71
  72     if( NULL == pFrameView )
  73     {
  74         DrawDocShell* pDocShell = pDrawDoc->GetDocSh();
  75
  76         if ( pDocShell )
  77         {
  78             // document is loaded, is there a FrameView?
  79             sal_uLong nSdViewShellCount = 0;
  80             SfxViewFrame* pSfxViewFrame = SfxViewFrame::GetFirst(pDocShell);
  81
  82             while (pSfxViewFrame)
  83             {
  84                 // Count the FrameViews and remember the type of the main
  85                 // view shell.
  86                 SfxViewShell* pSfxViewSh = pSfxViewFrame->GetViewShell();
  87                 ViewShellBase* pBase = PTR_CAST(ViewShellBase, pSfxViewSh );
  88
  89                 if (pBase != NULL)
  90                 {
  91                     nSdViewShellCount++;
  92
  93                     OUString sViewURL;
  94                     Reference<drawing::framework::XView> xView (
  95                         framework::FrameworkHelper::Instance(*pBase)->GetView(
  96                             drawing::framework::ResourceId::create(
  97                                 ::comphelper::getProcessComponentContext(),
  98                                 framework::FrameworkHelper::msCenterPaneURL)));
  99                     if (xView.is())
 100                         sViewURL = xView->getResourceId()->getResourceURL();
 101
 102                     switch (framework::FrameworkHelper::GetViewId(sViewURL))
 103                     {
 104                         default:
 105 //                        case ViewShell::ST_IMPRESS:
 106 //                        case ViewShell::ST_NOTES:
 107 //                        case ViewShell::ST_HANDOUT:
 108                             mnPresViewShellId = SID_VIEWSHELL0;
 109                             break;
 110
 111                         case ViewShell::ST_SLIDE_SORTER:
 112                             mnPresViewShellId = SID_VIEWSHELL1;
 113                             break;
 114
 115                         case ViewShell::ST_OUTLINE:
 116                             mnPresViewShellId = SID_VIEWSHELL2;
 117                             break;
 118                     }
 119                 }
 120
 121                 pSfxViewFrame = SfxViewFrame::GetNext(*pSfxViewFrame, pDocShell);
 122             }
 123
 124             SdDrawDocument* pDoc = pDocShell->GetDoc();
 125             pFrameView = pDoc->GetFrameView(nSdViewShellCount);
 126         }
 127     }
 128
 129     if (pFrameView)
 130     {
 131         // initialize FrameView with the FrameView of the DocShell
 132         SetRuler( pFrameView->HasRuler() );
 133         SetGridCoarse( pFrameView->GetGridCoarse() );
 134         SetGridFine( pFrameView->GetGridFine() );
 135         SetSnapGridWidth(pFrameView->GetSnapGridWidthX(), pFrameView->GetSnapGridWidthY());
 136         SetGridVisible( pFrameView->IsGridVisible() );
 137         SetGridFront( pFrameView->IsGridFront() );
 138         SetSnapAngle( pFrameView->GetSnapAngle() );
 139         SetGridSnap( pFrameView->IsGridSnap() );
 140         SetBordSnap( pFrameView->IsBordSnap() );
 141         SetHlplSnap( pFrameView->IsHlplSnap() );
 142         SetOFrmSnap( pFrameView->IsOFrmSnap() );
 143         SetOPntSnap( pFrameView->IsOPntSnap() );
 144         SetOConSnap( pFrameView->IsOConSnap() );
 145         SetHlplVisible( pFrameView->IsHlplVisible() );
 146         SetDragStripes( pFrameView->IsDragStripes() );
 147         SetPlusHandlesAlwaysVisible( pFrameView->IsPlusHandlesAlwaysVisible() );
 148         SetFrameDragSingles( pFrameView->IsFrameDragSingles() );
 149         SetSnapMagneticPixel( pFrameView->GetSnapMagneticPixel() );
 150         SetMarkedHitMovesAlways( pFrameView->IsMarkedHitMovesAlways() );
 151         SetMoveOnlyDragging( pFrameView->IsMoveOnlyDragging() );
 152         SetCrookNoContortion( pFrameView->IsCrookNoContortion() );
 153         SetSlantButShear( pFrameView->IsSlantButShear() );
 154         SetNoDragXorPolys( pFrameView->IsNoDragXorPolys() );
 155         SetAngleSnapEnabled( pFrameView->IsAngleSnapEnabled() );
 156         SetBigOrtho( pFrameView->IsBigOrtho() );
 157         SetOrtho( pFrameView->IsOrtho() );
 158         SetEliminatePolyPointLimitAngle( pFrameView->GetEliminatePolyPointLimitAngle() );
 159         SetEliminatePolyPoints( pFrameView->IsEliminatePolyPoints() );
 160         SetDesignMode( pFrameView->IsDesignMode() );
 161
 162         SetSolidDragging( pFrameView->IsSolidDragging() );
 163
 164         maVisibleLayers = pFrameView->GetVisibleLayers();
 165         maPrintableLayers = pFrameView->GetPrintableLayers();
 166         maLockedLayers = pFrameView->GetLockedLayers();
 167         maStandardHelpLines = pFrameView->GetStandardHelpLines();
 168         maNotesHelpLines = pFrameView->GetNotesHelpLines();
 169         maHandoutHelpLines = pFrameView->GetHandoutHelpLines();
 170         SetActiveLayer( pFrameView->GetActiveLayer() );
 171         mbNoColors = pFrameView->IsNoColors();
 172         mbNoAttribs = pFrameView->IsNoAttribs() ;
 173         maVisArea = pFrameView->GetVisArea();
 174         mePageKind = pFrameView->GetPageKind();
 175         mePageKindOnLoad = pFrameView->GetPageKindOnLoad();
 176         mnSelectedPage = pFrameView->GetSelectedPage();
 177         mnSelectedPageOnLoad = pFrameView->GetSelectedPageOnLoad();
 178         meStandardEditMode = pFrameView->GetViewShEditMode(PK_STANDARD);
 179         meNotesEditMode = pFrameView->GetViewShEditMode(PK_NOTES);
 180         meHandoutEditMode = pFrameView->GetViewShEditMode(PK_HANDOUT);
 181         SetViewShEditModeOnLoad(pFrameView->GetViewShEditModeOnLoad());
 182         mbLayerMode = pFrameView->IsLayerMode();
 183         mbQuickEdit = pFrameView->IsQuickEdit();
 184
 185         // #i26631#
 186         SetMasterPagePaintCaching( pFrameView->IsMasterPagePaintCaching() );
 187
 188         SetDragWithCopy( pFrameView->IsDragWithCopy() );
 189         mbDoubleClickTextEdit = pFrameView->IsDoubleClickTextEdit();
 190         mbClickChangeRotation = pFrameView->IsClickChangeRotation();
 191         mnSlidesPerRow = pFrameView->GetSlidesPerRow();
 192         mnDrawMode = pFrameView->GetDrawMode();
 193         mbIsNavigatorShowingAllShapes = pFrameView->IsNavigatorShowingAllShapes();
 194         SetPreviousViewShellType (pFrameView->GetPreviousViewShellType());
 195         SetViewShellTypeOnLoad (pFrameView->GetViewShellTypeOnLoad());
 196     }
 197     else
 198     {
 199         // initialize FrameView with the application data
 200         maVisibleLayers.SetAll();
 201         maPrintableLayers.SetAll();
 202         SetGridCoarse( Size( 1000, 1000 ) );
 203         SetSnapGridWidth(Fraction(1000, 1), Fraction(1000, 1));
 204         SetActiveLayer( SD_RESSTR(STR_LAYER_LAYOUT) );
 205         mbNoColors = true;
 206         mbNoAttribs = false;
 207         maVisArea = Rectangle( Point(), Size(0, 0) );
 208         mePageKind = PK_STANDARD;
 209         mePageKindOnLoad = PK_STANDARD;
 210         mnSelectedPage = 0;
 211         mnSelectedPageOnLoad = 0;
 212         meStandardEditMode = EM_PAGE;
 213         meNotesEditMode = EM_PAGE;
 214         meHandoutEditMode = EM_MASTERPAGE;
 215         SetViewShEditModeOnLoad(EM_PAGE);
 216         mbLayerMode = false;
 217         SetEliminatePolyPoints(false);
 218         mbDoubleClickTextEdit = false;
 219         mbClickChangeRotation = false;
 220         mnSlidesPerRow = 4;
 221
 222         {
 223             bool bUseContrast = Application::GetSettings().GetStyleSettings().GetHighContrastMode();
 224             mnDrawMode = bUseContrast ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR;
 225         }
 226         mbIsNavigatorShowingAllShapes = false;
 227         SetPreviousViewShellType (ViewShell::ST_NONE);
 228         SetViewShellTypeOnLoad (ViewShell::ST_IMPRESS);
 229
 230         // get default for design mode
 231         bool bInitDesignMode = pDrawDoc->GetOpenInDesignMode();
 232         if( pDrawDoc->OpenInDesignModeIsDefaulted() )
 233         {
 234             bInitDesignMode = true;
 235         }
 236
 237         SfxObjectShell* pObjShell = pDrawDoc->GetObjectShell();
 238         if( pObjShell && pObjShell->IsReadOnly() )
 239             bInitDesignMode = false;
 240         SetDesignMode( bInitDesignMode );
 241
 242         Update( SD_MOD()->GetSdOptions(pDrawDoc->GetDocumentType()) );
 243     }
 244
 245 }
 246
 247 FrameView::~FrameView()
 248 {
 249 }
 250
 251 void FrameView::Connect()
 252 {
 253     mnRefCount++;
 254 }
 255
 256 void FrameView::Disconnect()
 257 {
 258     if (mnRefCount > 0)
 259     {
 260         mnRefCount--;
 261     }
 262
 263     if (mnRefCount == 0)
 264     {
 265         delete this;
 266     }
 267 }
 268
 269 /**
 270  * Update with data from the specified SdOptions
 271  */
 272 void FrameView::Update(SdOptions* pOptions)
 273 {
 274     if (pOptions)
 275     {
 276         mbRuler = pOptions->IsRulerVisible();
 277         SetGridVisible( pOptions->IsGridVisible() );
 278         SetSnapAngle( pOptions->GetAngle() );
 279         SetGridSnap( pOptions->IsUseGridSnap() );
 280         SetBordSnap( pOptions->IsSnapBorder()  );
 281         SetHlplSnap( pOptions->IsSnapHelplines() );
 282         SetOFrmSnap( pOptions->IsSnapFrame() );
 283         SetOPntSnap( pOptions->IsSnapPoints() );
 284         SetHlplVisible( pOptions->IsHelplines() );
 285         SetDragStripes( pOptions->IsDragStripes() );
 286         SetPlusHandlesAlwaysVisible( pOptions->IsHandlesBezier() );
 287         SetSnapMagneticPixel( pOptions->GetSnapArea() );
 288         SetMarkedHitMovesAlways( pOptions->IsMarkedHitMovesAlways() );
 289         SetMoveOnlyDragging( pOptions->IsMoveOnlyDragging() );
 290         SetSlantButShear( pOptions->IsMoveOnlyDragging() );
 291         SetNoDragXorPolys ( !pOptions->IsMoveOutline() );
 292         SetCrookNoContortion( pOptions->IsCrookNoContortion() );
 293         SetAngleSnapEnabled( pOptions->IsRotate() );
 294         SetBigOrtho( pOptions->IsBigOrtho() );
 295         SetOrtho( pOptions->IsOrtho() );
 296         SetEliminatePolyPointLimitAngle( pOptions->GetEliminatePolyPointLimitAngle() );
 297         GetModel()->SetPickThroughTransparentTextFrames( pOptions->IsPickThrough() );
 298
 299         SetSolidDragging( pOptions->IsSolidDragging() );
 300
 301         SetGridCoarse( Size( pOptions->GetFieldDrawX(), pOptions->GetFieldDrawY() ) );
 302         SetGridFine( Size( pOptions->GetFieldDivisionX(), pOptions->GetFieldDivisionY() ) );
 303         Fraction aFractX(pOptions->GetFieldDrawX(), pOptions->GetFieldDrawX() / ( pOptions->GetFieldDivisionX() ? pOptions->GetFieldDivisionX() : 1 ));
 304         Fraction aFractY(pOptions->GetFieldDrawY(), pOptions->GetFieldDrawY() / ( pOptions->GetFieldDivisionY() ? pOptions->GetFieldDivisionY() : 1 ));
 305         SetSnapGridWidth(aFractX, aFractY);
 306         SetQuickEdit(pOptions->IsQuickEdit());
 307
 308         // #i26631#
 309         SetMasterPagePaintCaching( pOptions->IsMasterPagePaintCaching() );
 310
 311         SetDragWithCopy(pOptions->IsDragWithCopy());
 312         SetDoubleClickTextEdit( pOptions->IsDoubleClickTextEdit() );
 313         SetClickChangeRotation( pOptions->IsClickChangeRotation() );
 314     }
 315 }
 316
 317 /**
 318  * Set EditMode (Page or MasterPage) of working mode
 319  */
 320 void FrameView::SetViewShEditMode(EditMode eMode, PageKind eKind)
 321 {
 322     if (eKind == PK_STANDARD)
 323     {
 324         meStandardEditMode = eMode;
 325     }
 326     else if (eKind == PK_NOTES)
 327     {
 328         meNotesEditMode = eMode;
 329     }
 330     else if (eKind == PK_HANDOUT)
 331     {
 332         meHandoutEditMode = eMode;
 333     }
 334 }
 335
 336 /**
 337  * Return EditMode (Page or MasterPage) of working mode
 338  */
 339 EditMode FrameView::GetViewShEditMode(PageKind eKind)
 340 {
 341     EditMode eMode = EM_PAGE;
 342
 343     if (eKind == PK_STANDARD)
 344     {
 345         eMode = meStandardEditMode;
 346     }
 347     else if (eKind == PK_NOTES)
 348     {
 349         eMode = meNotesEditMode;
 350     }
 351     else if (eKind == PK_HANDOUT)
 352     {
 353         eMode = meHandoutEditMode;
 354     }
 355
 356     return eMode;
 357 }
 358
 359 void FrameView::SetViewShEditModeOnLoad (EditMode eMode)
 360 {
 361     meEditModeOnLoad = eMode;
 362 }
 363
 364 static OUString createHelpLinesString( const SdrHelpLineList& rHelpLines )
 365 {
 366     OUStringBuffer aLines;
 367
 368     const sal_uInt16 nCount = rHelpLines.GetCount();
 369     for( sal_uInt16 nHlpLine = 0; nHlpLine < nCount; nHlpLine++ )
 370     {
 371         const SdrHelpLine& rHelpLine = rHelpLines[nHlpLine];
 372         const Point& rPos = rHelpLine.GetPos();
 373
 374         switch( rHelpLine.GetKind() )
 375         {
 376             case SDRHELPLINE_POINT:
 377                 aLines.append( 'P' );
 378                 aLines.append( (sal_Int32)rPos.X() );
 379                 aLines.append( ',' );
 380                 aLines.append( (sal_Int32)rPos.Y() );
 381                 break;
 382             case SDRHELPLINE_VERTICAL:
 383                 aLines.append( 'V' );
 384                 aLines.append( (sal_Int32)rPos.X() );
 385                 break;
 386             case SDRHELPLINE_HORIZONTAL:
 387                 aLines.append( 'H' );
 388                 aLines.append( (sal_Int32)rPos.Y() );
 389                 break;
 390             default:
 391                 OSL_FAIL( "Unsupported helpline Kind!" );
 392         }
 393     }
 394
 395     return aLines.makeStringAndClear();
 396 }
 397
 398 #define addValue( n, v ) push_back( std::pair< OUString, Any >( OUString( n ), v ) )
 399 void FrameView::WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rValues, bool )
 400 {
 401     std::vector< std::pair< OUString, Any > > aUserData;
 402
 403     aUserData.addValue( sUNO_View_GridIsVisible, makeAny( IsGridVisible() ) );
 404     aUserData.addValue( sUNO_View_GridIsFront, makeAny( IsGridFront() ) );
 405     aUserData.addValue( sUNO_View_IsSnapToGrid, makeAny( IsGridSnap() ) );
 406     aUserData.addValue( sUNO_View_IsSnapToPageMargins, makeAny( IsBordSnap() ) );
 407     aUserData.addValue( sUNO_View_IsSnapToSnapLines, makeAny( IsHlplSnap() ) );
 408     aUserData.addValue( sUNO_View_IsSnapToObjectFrame, makeAny( IsOFrmSnap() ) );
 409     aUserData.addValue( sUNO_View_IsSnapToObjectPoints, makeAny( IsOPntSnap() ) );
 410
 411     aUserData.addValue( sUNO_View_IsPlusHandlesAlwaysVisible, makeAny( IsPlusHandlesAlwaysVisible() ) );
 412     aUserData.addValue( sUNO_View_IsFrameDragSingles, makeAny( IsFrameDragSingles() ) );
 413
 414     aUserData.addValue( sUNO_View_EliminatePolyPointLimitAngle, makeAny( (sal_Int32)GetEliminatePolyPointLimitAngle() ) );
 415     aUserData.addValue( sUNO_View_IsEliminatePolyPoints, makeAny( IsEliminatePolyPoints() ) );
 416
 417     Any aAny;
 418     GetVisibleLayers().QueryValue( aAny );
 419     aUserData.addValue( sUNO_View_VisibleLayers, aAny );
 420
 421     GetPrintableLayers().QueryValue( aAny );
 422     aUserData.addValue( sUNO_View_PrintableLayers, aAny );
 423
 424     GetLockedLayers().QueryValue( aAny );
 425     aUserData.addValue( sUNO_View_LockedLayers, aAny );
 426
 427     aUserData.addValue( sUNO_View_NoAttribs, makeAny( IsNoAttribs() ) );
 428     aUserData.addValue( sUNO_View_NoColors, makeAny( IsNoColors() ) );
 429
 430     if( GetStandardHelpLines().GetCount() )
 431         aUserData.addValue( sUNO_View_SnapLinesDrawing, makeAny( createHelpLinesString( GetStandardHelpLines() ) ) );
 432
 433     if( GetNotesHelpLines().GetCount() )
 434         aUserData.addValue( sUNO_View_SnapLinesNotes, makeAny( createHelpLinesString( GetNotesHelpLines() ) ) );
 435
 436     if( GetHandoutHelpLines().GetCount() )
 437         aUserData.addValue( sUNO_View_SnapLinesHandout, makeAny( createHelpLinesString( GetHandoutHelpLines() ) ) );
 438
 439     aUserData.addValue( sUNO_View_RulerIsVisible, makeAny( HasRuler() ) );
 440     aUserData.addValue( sUNO_View_PageKind, makeAny( (sal_Int16)GetPageKind() ) );
 441     aUserData.addValue( sUNO_View_SelectedPage, makeAny( (sal_Int16)GetSelectedPage() ) );
 442     aUserData.addValue( sUNO_View_IsLayerMode, makeAny( IsLayerMode() ) );
 443
 444     aUserData.addValue( sUNO_View_IsDoubleClickTextEdit,  makeAny( IsDoubleClickTextEdit() ) );
 445     aUserData.addValue( sUNO_View_IsClickChangeRotation, makeAny( IsClickChangeRotation() ) );
 446
 447     aUserData.addValue( sUNO_View_SlidesPerRow, makeAny( (sal_Int16)GetSlidesPerRow() ) );
 448     aUserData.addValue( sUNO_View_EditModeStandard, makeAny( (sal_Int32)GetViewShEditMode( PK_STANDARD ) ) );
 449     aUserData.addValue( sUNO_View_EditModeNotes, makeAny( (sal_Int32)GetViewShEditMode( PK_NOTES ) ) );
 450     aUserData.addValue( sUNO_View_EditModeHandout, makeAny( (sal_Int32)GetViewShEditMode( PK_HANDOUT ) ) );
 451
 452     {
 453         const Rectangle aVisArea = GetVisArea();
 454
 455         aUserData.addValue( sUNO_View_VisibleAreaTop, makeAny( (sal_Int32)aVisArea.Top() ) );
 456         aUserData.addValue( sUNO_View_VisibleAreaLeft, makeAny( (sal_Int32)aVisArea.Left() ) );
 457         aUserData.addValue( sUNO_View_VisibleAreaWidth, makeAny( (sal_Int32)aVisArea.GetWidth() ) );
 458         aUserData.addValue( sUNO_View_VisibleAreaHeight, makeAny( (sal_Int32)aVisArea.GetHeight() ) );
 459     }
 460
 461     aUserData.addValue( sUNO_View_GridCoarseWidth, makeAny( (sal_Int32)GetGridCoarse().Width() ) );
 462     aUserData.addValue( sUNO_View_GridCoarseHeight, makeAny( (sal_Int32)GetGridCoarse().Height() ) );
 463     aUserData.addValue( sUNO_View_GridFineWidth, makeAny( (sal_Int32)GetGridFine().Width() ) );
 464     aUserData.addValue( sUNO_View_GridFineHeight, makeAny( (sal_Int32)GetGridFine().Height() ) );
 465     aUserData.addValue( sUNO_View_GridSnapWidthXNumerator, makeAny( (sal_Int32)GetSnapGridWidthX().GetNumerator() ) );
 466     aUserData.addValue( sUNO_View_GridSnapWidthXDenominator, makeAny( (sal_Int32)GetSnapGridWidthX().GetDenominator() ) );
 467     aUserData.addValue( sUNO_View_GridSnapWidthYNumerator, makeAny( (sal_Int32)GetSnapGridWidthY().GetNumerator() ) );
 468     aUserData.addValue( sUNO_View_GridSnapWidthYDenominator, makeAny( (sal_Int32)GetSnapGridWidthY().GetDenominator() ) );
 469     aUserData.addValue( sUNO_View_IsAngleSnapEnabled, makeAny( IsAngleSnapEnabled() ) );
 470     aUserData.addValue( sUNO_View_SnapAngle, makeAny( (sal_Int32)GetSnapAngle() ) );
 471
 472     const sal_Int32 nOldLength = rValues.getLength();
 473     rValues.realloc( nOldLength + aUserData.size() );
 474
 475     PropertyValue* pValue = &(rValues.getArray()[nOldLength]);
 476
 477     std::vector< std::pair< OUString, Any > >::iterator aIter( aUserData.begin() );
 478     for( ; aIter != aUserData.end(); ++aIter, ++pValue )
 479     {
 480         pValue->Name = (*aIter).first;
 481         pValue->Value = (*aIter).second;
 482     }
 483 }
 484 #undef addValue
 485
 486 static void createHelpLinesFromString( const OUString& rLines, SdrHelpLineList& rHelpLines )
 487 {
 488     const sal_Unicode * pStr = rLines.getStr();
 489     SdrHelpLine aNewHelpLine;
 490     OUStringBuffer sBuffer;
 491
 492     while( *pStr )
 493     {
 494         Point aPoint;
 495
 496         switch( *pStr )
 497         {
 498         case (sal_Unicode)'P':
 499             aNewHelpLine.SetKind( SDRHELPLINE_POINT );
 500             break;
 501         case (sal_Unicode)'V':
 502             aNewHelpLine.SetKind( SDRHELPLINE_VERTICAL );
 503             break;
 504         case (sal_Unicode)'H':
 505             aNewHelpLine.SetKind( SDRHELPLINE_HORIZONTAL );
 506             break;
 507         default:
 508             OSL_FAIL( "syntax error in snap lines settings string" );
 509             return;
 510         }
 511
 512         pStr++;
 513
 514         while( (*pStr >= '0' && *pStr <= '9') || (*pStr == '+') || (*pStr == '-') )
 515         {
 516             sBuffer.append( *pStr++ );
 517         }
 518
 519         sal_Int32 nValue = sBuffer.makeStringAndClear().toInt32();
 520
 521         if( aNewHelpLine.GetKind() == SDRHELPLINE_HORIZONTAL )
 522         {
 523             aPoint.Y() = nValue;
 524         }
 525         else
 526         {
 527             aPoint.X() = nValue;
 528
 529             if( aNewHelpLine.GetKind() == SDRHELPLINE_POINT )
 530             {
 531                 if( *pStr++ != ',' )
 532                     return;
 533
 534                 while( (*pStr >= '0' && *pStr <= '9') || (*pStr == '+') || (*pStr == '-')  )
 535                 {
 536                     sBuffer.append( *pStr++ );
 537                 }
 538
 539                 aPoint.Y() = sBuffer.makeStringAndClear().toInt32();
 540
 541             }
 542         }
 543
 544         aNewHelpLine.SetPos( aPoint );
 545         rHelpLines.Insert( aNewHelpLine );
 546     }
 547 }
 548
 549 void FrameView::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, bool )
 550 {
 551     const sal_Int32 nLength = rSequence.getLength();
 552     if (nLength)
 553     {
 554         SdDrawDocument* pDrawDocument = dynamic_cast<SdDrawDocument*>(GetModel());
 555         const bool bImpress = pDrawDocument && pDrawDocument->GetDocumentType() == DOCUMENT_TYPE_IMPRESS;
 556
 557         bool bBool = false;
 558         sal_Int32 nInt32 = 0;
 559         sal_Int16 nInt16 = 0;
 560         OUString aString;
 561
 562         sal_Int32 aSnapGridWidthXNum = GetSnapGridWidthX().GetNumerator();
 563         sal_Int32 aSnapGridWidthXDom = GetSnapGridWidthX().GetDenominator();
 564
 565         sal_Int32 aSnapGridWidthYNum = GetSnapGridWidthY().GetNumerator();
 566         sal_Int32 aSnapGridWidthYDom = GetSnapGridWidthY().GetDenominator();
 567
 568         const com::sun::star::beans::PropertyValue *pValue = rSequence.getConstArray();
 569         for (sal_Int16 i = 0 ; i < nLength; i++, pValue++ )
 570         {
 571             if ( pValue->Name == sUNO_View_ViewId )
 572             {
 573             }
 574             else if ( pValue->Name == sUNO_View_SnapLinesDrawing )
 575             {
 576                 if( pValue->Value >>= aString )
 577                 {
 578                     SdrHelpLineList aHelpLines;
 579                     createHelpLinesFromString( aString, aHelpLines );
 580                     SetStandardHelpLines( aHelpLines );
 581                 }
 582             }
 583             else if ( pValue->Name == sUNO_View_SnapLinesNotes )
 584             {
 585                 if( pValue->Value >>= aString )
 586                 {
 587                     SdrHelpLineList aHelpLines;
 588                     createHelpLinesFromString( aString, aHelpLines );
 589                     SetNotesHelpLines( aHelpLines );
 590                 }
 591             }
 592             else if ( pValue->Name == sUNO_View_SnapLinesHandout )
 593             {
 594                 if( pValue->Value >>= aString )
 595                 {
 596                     SdrHelpLineList aHelpLines;
 597                     createHelpLinesFromString( aString, aHelpLines );
 598                     SetHandoutHelpLines( aHelpLines );
 599                 }
 600             }
 601             else if ( pValue->Name == sUNO_View_RulerIsVisible )
 602             {
 603                 if( pValue->Value >>= bBool )
 604                 {
 605                     SetRuler( bBool );
 606                 }
 607             }
 608             else if ( pValue->Name == sUNO_View_PageKind )
 609             {
 610                 if( pValue->Value >>= nInt16 )
 611                 {
 612                     SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() );
 613                     if( pDoc && pDoc->GetDocSh() && ( SfxObjectCreateMode::EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) )
 614                         SetPageKind( (PageKind)nInt16 );
 615
 616                     SetPageKindOnLoad( (PageKind)nInt16 );
 617                 }
 618             }
 619             else if ( pValue->Name == sUNO_View_SelectedPage )
 620             {
 621                 if( pValue->Value >>= nInt16 )
 622                 {
 623                     SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() );
 624                     if( pDoc && pDoc->GetDocSh() && ( SfxObjectCreateMode::EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) )
 625                         SetSelectedPage( (sal_uInt16)nInt16 );
 626
 627                     SetSelectedPageOnLoad( (sal_uInt16)nInt16 );
 628                 }
 629             }
 630             else if ( pValue->Name == sUNO_View_IsLayerMode )
 631             {
 632                 if( pValue->Value >>= bBool )
 633                 {
 634                     SetLayerMode( bBool );
 635                 }
 636             }
 637             else if ( pValue->Name == sUNO_View_IsDoubleClickTextEdit )
 638             {
 639                 if( pValue->Value >>= bBool )
 640                 {
 641                     SetDoubleClickTextEdit( bBool );
 642                 }
 643             }
 644             else if ( pValue->Name == sUNO_View_IsClickChangeRotation )
 645             {
 646                 if( pValue->Value >>= bBool )
 647                 {
 648                     SetClickChangeRotation( bBool );
 649                 }
 650             }
 651             else if ( pValue->Name == sUNO_View_SlidesPerRow )
 652             {
 653                 if( pValue->Value >>= nInt16 )
 654                 {
 655                     SetSlidesPerRow( (sal_uInt16)nInt16 );
 656                 }
 657             }
 658             else if ( pValue->Name == sUNO_View_EditModeStandard )
 659             {
 660                 if( pValue->Value >>= nInt32 )
 661                 {
 662                     SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() );
 663                     if( pDoc && pDoc->GetDocSh() && ( SfxObjectCreateMode::EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) )
 664                         SetViewShEditMode( (EditMode)nInt32, PK_STANDARD );
 665                 }
 666             }
 667             else if ( pValue->Name == sUNO_View_EditModeNotes )
 668             {
 669                 if( pValue->Value >>= nInt32 )
 670                 {
 671                     SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() );
 672                     if( pDoc && pDoc->GetDocSh() && ( SfxObjectCreateMode::EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) )
 673                         SetViewShEditMode( (EditMode)nInt32, PK_NOTES );
 674                 }
 675             }
 676             else if ( pValue->Name == sUNO_View_EditModeHandout )
 677             {
 678                 if( pValue->Value >>= nInt32 )
 679                 {
 680                     SdDrawDocument* pDoc = dynamic_cast< SdDrawDocument* >( GetModel() );
 681                     if( pDoc && pDoc->GetDocSh() && ( SfxObjectCreateMode::EMBEDDED == pDoc->GetDocSh()->GetCreateMode() ) )
 682                         SetViewShEditMode( (EditMode)nInt32, PK_HANDOUT );
 683                 }
 684             }
 685             else if ( pValue->Name == sUNO_View_VisibleAreaTop )
 686             {
 687                 sal_Int32 nTop = 0;
 688                 if( pValue->Value >>= nTop )
 689                 {
 690                     Rectangle aVisArea( GetVisArea() );
 691                     aVisArea.Bottom() += nTop - aVisArea.Top();
 692                     aVisArea.Top() = nTop;
 693                     SetVisArea( aVisArea );
 694                 }
 695             }
 696             else if ( pValue->Name == sUNO_View_VisibleAreaLeft )
 697             {
 698                 sal_Int32 nLeft = 0;
 699                 if( pValue->Value >>= nLeft )
 700                 {
 701                     Rectangle aVisArea( GetVisArea() );
 702                     aVisArea.Right() += nLeft - aVisArea.Left();
 703                     aVisArea.Left() = nLeft;
 704                     SetVisArea( aVisArea );
 705                 }
 706             }
 707             else if ( pValue->Name == sUNO_View_VisibleAreaWidth )
 708             {
 709                 sal_Int32 nWidth = 0;
 710                 if( pValue->Value >>= nWidth )
 711                 {
 712                     Rectangle aVisArea( GetVisArea() );
 713                     aVisArea.Right() = aVisArea.Left() + nWidth - 1;
 714                     SetVisArea( aVisArea );
 715                 }
 716             }
 717             else if ( pValue->Name == sUNO_View_VisibleAreaHeight )
 718             {
 719                 sal_Int32 nHeight = 0;
 720                 if( pValue->Value >>= nHeight )
 721                 {
 722                     Rectangle aVisArea( GetVisArea() );
 723                     aVisArea.Bottom() = nHeight + aVisArea.Top() - 1;
 724                     SetVisArea( aVisArea );
 725                 }
 726             }
 727
 728             else if ( pValue->Name == sUNO_View_GridIsVisible )
 729             {
 730                 if( pValue->Value >>= bBool )
 731                 {
 732                     SetGridVisible( bBool );
 733                 }
 734             }
 735
 736             else if ( pValue->Name == sUNO_View_IsSnapToGrid )
 737             {
 738                 if( pValue->Value >>= bBool )
 739                 {
 740                     SetGridSnap( bBool );
 741                 }
 742             }
 743             else if ( pValue->Name == sUNO_View_GridIsFront )
 744             {
 745                 if( pValue->Value >>= bBool )
 746                 {
 747                     SetGridFront( bBool );
 748                 }
 749             }
 750             else if ( pValue->Name == sUNO_View_IsSnapToPageMargins )
 751             {
 752                 if( pValue->Value >>= bBool )
 753                 {
 754                     SetBordSnap( bBool );
 755                 }
 756             }
 757             else if ( pValue->Name == sUNO_View_IsSnapToSnapLines )
 758             {
 759                 if( pValue->Value >>= bBool )
 760                 {
 761                     SetHlplSnap( bBool );
 762                 }
 763             }
 764             else if ( pValue->Name == sUNO_View_IsSnapToObjectFrame )
 765             {
 766                 if( pValue->Value >>= bBool )
 767                 {
 768                     SetOFrmSnap( bBool );
 769                 }
 770             }
 771             else if ( pValue->Name == sUNO_View_IsSnapToObjectPoints )
 772             {
 773                 if( pValue->Value >>= bBool )
 774                 {
 775                     SetOPntSnap( bBool );
 776                 }
 777             }
 778             else if ( pValue->Name == sUNO_View_IsPlusHandlesAlwaysVisible )
 779             {
 780                 if( pValue->Value >>= bBool )
 781                 {
 782                     SetPlusHandlesAlwaysVisible( bBool );
 783                 }
 784             }
 785             else if ( pValue->Name == sUNO_View_IsFrameDragSingles )
 786             {
 787                 if( pValue->Value >>= bBool )
 788                 {
 789                     SetFrameDragSingles( bBool );
 790                 }
 791             }
 792             else if ( pValue->Name == sUNO_View_EliminatePolyPointLimitAngle )
 793             {
 794                 if( pValue->Value >>= nInt32 )
 795                 {
 796                     SetEliminatePolyPointLimitAngle( nInt32 );
 797                 }
 798             }
 799             else if ( pValue->Name == sUNO_View_IsEliminatePolyPoints )
 800             {
 801                 if( pValue->Value >>= bBool )
 802                 {
 803                     SetEliminatePolyPoints( bBool );
 804                 }
 805             }
 806             else if ( pValue->Name == sUNO_View_ActiveLayer )
 807             {
 808                 if( pValue->Value >>= aString )
 809                 {
 810                     SetActiveLayer( aString );
 811                 }
 812             }
 813             else if ( pValue->Name == sUNO_View_NoAttribs )
 814             {
 815                 if( pValue->Value >>= bBool )
 816                 {
 817                     SetNoAttribs( bBool );
 818                 }
 819             }
 820             else if ( pValue->Name == sUNO_View_NoColors )
 821             {
 822                 if( pValue->Value >>= bBool )
 823                 {
 824                     SetNoColors( bBool );
 825                 }
 826             }
 827             else if ( pValue->Name == sUNO_View_GridCoarseWidth )
 828             {
 829                 if( pValue->Value >>= nInt32 )
 830                 {
 831                     const Size aCoarse( nInt32, GetGridCoarse().Height() );
 832                     SetGridCoarse( aCoarse );
 833                 }
 834             }
 835             else if ( pValue->Name == sUNO_View_GridCoarseHeight )
 836             {
 837                 if( pValue->Value >>= nInt32 )
 838                 {
 839                     const Size aCoarse( GetGridCoarse().Width(), nInt32 );
 840                     SetGridCoarse( aCoarse );
 841                 }
 842             }
 843             else if ( pValue->Name == sUNO_View_GridFineWidth )
 844             {
 845                 if( pValue->Value >>= nInt32 )
 846                 {
 847                     const Size aCoarse( nInt32, GetGridFine().Height() );
 848                     SetGridFine( aCoarse );
 849                 }
 850             }
 851             else if ( pValue->Name == sUNO_View_GridFineHeight )
 852             {
 853                 if( pValue->Value >>= nInt32 )
 854                 {
 855                     const Size aCoarse( GetGridFine().Width(), nInt32 );
 856                     SetGridFine( aCoarse );
 857                 }
 858             }
 859             else if ( pValue->Name == sUNO_View_IsAngleSnapEnabled )
 860             {
 861                 if( pValue->Value >>= bBool )
 862                 {
 863                     SetAngleSnapEnabled( bBool );
 864                 }
 865             }
 866             else if ( pValue->Name == sUNO_View_SnapAngle )
 867             {
 868                 if( pValue->Value >>= nInt32 )
 869                 {
 870                     SetSnapAngle( nInt32 );
 871                 }
 872             }
 873             else if ( pValue->Name == sUNO_View_GridSnapWidthXNumerator )
 874             {
 875                 pValue->Value >>= aSnapGridWidthXNum;
 876             }
 877             else if ( pValue->Name == sUNO_View_GridSnapWidthXDenominator )
 878             {
 879                 pValue->Value >>= aSnapGridWidthXDom;
 880             }
 881             else if ( pValue->Name == sUNO_View_GridSnapWidthYNumerator )
 882             {
 883                 pValue->Value >>= aSnapGridWidthYNum;
 884             }
 885             else if ( pValue->Name == sUNO_View_GridSnapWidthYDenominator )
 886             {
 887                 pValue->Value >>= aSnapGridWidthYDom;
 888             }
 889             else if (!bImpress && pValue->Name == sUNO_View_VisibleLayers  )
 890             {
 891                 SetOfByte aSetOfBytes;
 892                 aSetOfBytes.PutValue( pValue->Value );
 893                 SetVisibleLayers( aSetOfBytes );
 894             }
 895             else if (!bImpress && pValue->Name == sUNO_View_PrintableLayers )
 896             {
 897                 SetOfByte aSetOfBytes;
 898                 aSetOfBytes.PutValue( pValue->Value );
 899                 SetPrintableLayers( aSetOfBytes );
 900             }
 901             else if (!bImpress && pValue->Name == sUNO_View_LockedLayers )
 902             {
 903                 SetOfByte aSetOfBytes;
 904                 aSetOfBytes.PutValue( pValue->Value );
 905                 SetLockedLayers( aSetOfBytes );
 906             }
 907         }
 908
 909         switch (GetPageKindOnLoad())
 910         {
 911             case PK_STANDARD: SetViewShEditModeOnLoad(meStandardEditMode); break;
 912             case PK_NOTES: SetViewShEditModeOnLoad(meNotesEditMode); break;
 913             case PK_HANDOUT: SetViewShEditModeOnLoad(meHandoutEditMode); break;
 914             default: SetViewShEditModeOnLoad(EM_PAGE); break;
 915         }
 916
 917         const Fraction aSnapGridWidthX( aSnapGridWidthXNum, aSnapGridWidthXDom );
 918         const Fraction aSnapGridWidthY( aSnapGridWidthYNum, aSnapGridWidthYDom );
 919
 920         SetSnapGridWidth( aSnapGridWidthX, aSnapGridWidthY );
 921     }
 922 }
 923
 924 void FrameView::SetPreviousViewShellType (ViewShell::ShellType eType)
 925 {
 926     mePreviousViewShellType = eType;
 927 }
 928
 929 void FrameView::SetViewShellTypeOnLoad (ViewShell::ShellType eType)
 930 {
 931     meViewShellTypeOnLoad = eType;
 932 }
 933
 934 void FrameView::SetSelectedPage(sal_uInt16 nPage)
 935 {
 936     mnSelectedPage = nPage;
 937 }
 938
 939 void FrameView::SetIsNavigatorShowingAllShapes (const bool bIsNavigatorShowingAllShapes)
 940 {
 941     mbIsNavigatorShowingAllShapes = bIsNavigatorShowingAllShapes;
 942 }
 943
 944 } // end of namespace sd
 945
 946 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */