office-gobmx/sd/source/ui/view/frmview.cxx

1366 lines
No EOL
51 KiB
C++

/*************************************************************************
*
* $RCSfile: frmview.cxx,v $
*
* $Revision: 1.12 $
*
* last change: $Author: cl $ $Date: 2002-07-30 14:16:29 $
*
* The Contents of this file are made available subject to the terms of
* either of the following licenses
*
* - GNU Lesser General Public License Version 2.1
* - Sun Industry Standards Source License Version 1.1
*
* Sun Microsystems Inc., October, 2000
*
* GNU Lesser General Public License Version 2.1
* =============================================
* Copyright 2000 by Sun Microsystems, Inc.
* 901 San Antonio Road, Palo Alto, CA 94303, USA
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software Foundation.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
*
*
* Sun Industry Standards Source License Version 1.1
* =================================================
* The contents of this file are subject to the Sun Industry Standards
* Source License Version 1.1 (the "License"); You may not use this file
* except in compliance with the License. You may obtain a copy of the
* License at http://www.openoffice.org/license.html.
*
* Software provided under this License is provided on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING,
* WITHOUT LIMITATION, WARRANTIES THAT THE SOFTWARE IS FREE OF DEFECTS,
* MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE, OR NON-INFRINGING.
* See the License for the specific provisions governing your rights and
* obligations concerning the Software.
*
* The Initial Developer of the Original Code is: Sun Microsystems, Inc.
*
* Copyright: 2000 by Sun Microsystems, Inc.
*
* All Rights Reserved.
*
* Contributor(s): _______________________________________
*
*
************************************************************************/
#ifndef _SVXIDS_HRC
#include <svx/svxids.hrc>
#endif
#ifndef _SFX_TOPFRM_HXX //autogen wg. SfxTopViewFrame
#include <sfx2/topfrm.hxx>
#endif
#ifndef _COM_SUN_STAR_AWT_RECTANGLE_HPP_
#include <com/sun/star/awt/Rectangle.hpp>
#endif
#ifndef _RTL_USTRBUF_HXX_
#include <rtl/ustrbuf.hxx>
#endif
#ifndef _SD_UNOKYWDS_HXX_
#include "unokywds.hxx"
#endif
#include <vector>
#include "frmview.hxx"
#include "viewshel.hxx"
#include "drawdoc.hxx"
#include "docshell.hxx"
#include "optsitem.hxx"
#include "drviewsh.hxx"
#include "outlnvsh.hxx"
#include "slidvish.hxx"
#include "app.hxx"
#include "sdresid.hxx"
#include "pres.hxx"
#include "glob.hrc"
#include "sdiocmpt.hxx"
using namespace ::com::sun::star::uno;
using namespace ::com::sun::star::beans;
using namespace ::rtl;
using namespace ::std;
/*************************************************************************
|*
|* Ctor
|*
\************************************************************************/
FrameView::FrameView(SdDrawDocument* pDrawDoc, FrameView* pFrameView /* = NULK */)
: SdrView(pDrawDoc, (OutputDevice*) NULL),
nRefCount(0),
nPresViewShellId(SID_VIEWSHELL0),
nSlotId(SID_OBJECT_SELECT)
{
EndListening(*pDrawDoc);
EnableExtendedKeyInputDispatcher(FALSE);
EnableExtendedMouseEventDispatcher(FALSE);
EnableExtendedCommandEventDispatcher(FALSE);
SetGridFront( TRUE );
SetOConSnap( FALSE );
SetFrameDragSingles( TRUE );
SetSlidesPerRow(4);
if( NULL == pFrameView )
{
SdDrawDocShell* pDocShell = pDrawDoc->GetDocSh();
if ( pDocShell )
{
/**********************************************************************
* Das Dokument wurde geladen, ist eine FrameView vorhanden?
**********************************************************************/
ULONG nSdViewShellCount = 0;
SdViewShell* pViewSh = NULL;
SfxViewShell* pSfxViewSh = NULL;
SfxViewFrame* pSfxViewFrame = SfxViewFrame::GetFirst(pDocShell,
TYPE(SfxTopViewFrame));
while (pSfxViewFrame)
{
// Anzahl FrameViews ermitteln
pSfxViewSh = pSfxViewFrame->GetViewShell();
pViewSh = PTR_CAST( SdViewShell, pSfxViewSh );
if (pViewSh)
{
nSdViewShellCount++;
if (pViewSh->ISA(SdDrawViewShell))
{
nPresViewShellId = SID_VIEWSHELL0;
}
else if (pViewSh->ISA(SdSlideViewShell))
{
nPresViewShellId = SID_VIEWSHELL1;
}
else if (pViewSh->ISA(SdOutlineViewShell))
{
nPresViewShellId = SID_VIEWSHELL2;
}
}
pSfxViewFrame = SfxViewFrame::GetNext(*pSfxViewFrame, pDocShell,
TYPE(SfxTopViewFrame));
}
SdDrawDocument* pDoc = pDocShell->GetDoc();
pFrameView = pDoc->GetFrameView(nSdViewShellCount);
}
}
if (pFrameView)
{
/**********************************************************************
* FrameView mit der FrameView der DocShell initialisieren
**********************************************************************/
SetRuler( pFrameView->HasRuler() );
SetGridCoarse( pFrameView->GetGridCoarse() );
SetGridFine( pFrameView->GetGridFine() );
SetSnapGrid( pFrameView->GetSnapGrid() );
SetSnapGridWidth(pFrameView->GetSnapGridWidthX(), pFrameView->GetSnapGridWidthY());
SetGridVisible( pFrameView->IsGridVisible() );
SetGridFront( pFrameView->IsGridFront() );
SetSnapAngle( pFrameView->GetSnapAngle() );
SetGridSnap( pFrameView->IsGridSnap() );
SetBordSnap( pFrameView->IsBordSnap() );
SetHlplSnap( pFrameView->IsHlplSnap() );
SetOFrmSnap( pFrameView->IsOFrmSnap() );
SetOPntSnap( pFrameView->IsOPntSnap() );
SetOConSnap( pFrameView->IsOConSnap() );
SetHlplVisible( pFrameView->IsHlplVisible() );
SetDragStripes( pFrameView->IsDragStripes() );
SetPlusHandlesAlwaysVisible( pFrameView->IsPlusHandlesAlwaysVisible() );
SetFrameDragSingles( pFrameView->IsFrameDragSingles() );
SetSnapMagneticPixel( pFrameView->GetSnapMagneticPixel() );
SetMarkedHitMovesAlways( pFrameView->IsMarkedHitMovesAlways() );
SetMoveOnlyDragging( pFrameView->IsMoveOnlyDragging() );
SetCrookNoContortion( pFrameView->IsCrookNoContortion() );
SetSlantButShear( pFrameView->IsSlantButShear() );
SetNoDragXorPolys( pFrameView->IsNoDragXorPolys() );
SetAngleSnapEnabled( pFrameView->IsAngleSnapEnabled() );
SetBigOrtho( pFrameView->IsBigOrtho() );
SetOrtho( pFrameView->IsOrtho() );
SetEliminatePolyPointLimitAngle( pFrameView->GetEliminatePolyPointLimitAngle() );
SetEliminatePolyPoints( pFrameView->IsEliminatePolyPoints() );
SetMasterPagePaintCaching( pFrameView->IsMasterPagePaintCaching() );
SetLineDraft( pFrameView->IsLineDraft() );
SetFillDraft( pFrameView->IsFillDraft() );
SetTextDraft( pFrameView->IsTextDraft() );
SetGrafDraft( pFrameView->IsGrafDraft() );
SetSolidMarkHdl( pFrameView->IsSolidMarkHdl() );
SetSolidDragging( pFrameView->IsSolidDragging() );
aVisibleLayers = pFrameView->GetVisibleLayers();
aPrintableLayers = pFrameView->GetPrintableLayers();
aLockedLayers = pFrameView->GetLockedLayers();
aStandardHelpLines = pFrameView->GetStandardHelpLines();
aNotesHelpLines = pFrameView->GetNotesHelpLines();
aHandoutHelpLines = pFrameView->GetHandoutHelpLines();
SetActiveLayer( pFrameView->GetActiveLayer() );
bNoColors = pFrameView->IsNoColors();
bNoAttribs = pFrameView->IsNoAttribs() ;
aVisArea = pFrameView->GetVisArea();
ePageKind = pFrameView->GetPageKind();
nSelectedPage = pFrameView->GetSelectedPage();
eStandardEditMode = pFrameView->GetViewShEditMode(PK_STANDARD);
eNotesEditMode = pFrameView->GetViewShEditMode(PK_NOTES);
eHandoutEditMode = pFrameView->GetViewShEditMode(PK_HANDOUT);
bLayerMode = pFrameView->IsLayerMode();
bQuickEdit = pFrameView->IsQuickEdit();
bDragWithCopy = pFrameView->IsDragWithCopy();
bBigHandles = pFrameView->IsBigHandles();
bDoubleClickTextEdit = pFrameView->IsDoubleClickTextEdit();
bClickChangeRotation = pFrameView->IsClickChangeRotation();
nSlidesPerRow = pFrameView->GetSlidesPerRow();
nDrawMode = pFrameView->GetDrawMode();
nPreviewDrawMode = pFrameView->GetPreviewDrawMode();
bShowPreviewInPageMode = pFrameView->IsShowPreviewInPageMode() != 0;
bShowPreviewInMasterPageMode = pFrameView->IsShowPreviewInMasterPageMode() != 0;
bShowPreviewInOutlineMode = pFrameView->IsShowPreviewInOutlineMode() != 0;
}
else
{
/**********************************************************************
* FrameView mit den Applikationsdaten initialisieren
**********************************************************************/
aVisibleLayers.SetAll();
aPrintableLayers.SetAll();
SetGridCoarse( Size( 1000, 1000 ) );
SetSnapGrid( Size( 1000, 1000 ) );
SetSnapGridWidth(Fraction(1000, 1), Fraction(1000, 1));
SetActiveLayer( String( SdResId(STR_LAYER_LAYOUT) ) );
bNoColors = TRUE;
bNoAttribs = FALSE;
aVisArea = Rectangle( Point(), Size(0, 0) );
ePageKind = PK_STANDARD;
nSelectedPage = 0;
eStandardEditMode = EM_PAGE;
eNotesEditMode = EM_PAGE;
eHandoutEditMode = EM_MASTERPAGE;
bLayerMode = FALSE;
SetEliminatePolyPoints(FALSE);
{
SvtAccessibilityOptions aAccOptions;
bool bUseContrast = aAccOptions.GetIsForDrawings() && Application::GetSettings().GetStyleSettings().GetHighContrastMode();
nDrawMode = bUseContrast ? OUTPUT_DRAWMODE_CONTRAST : OUTPUT_DRAWMODE_COLOR;
}
nPreviewDrawMode = nDrawMode;
bShowPreviewInPageMode = FALSE;
bShowPreviewInMasterPageMode = TRUE;
bShowPreviewInOutlineMode = TRUE;
Update( SD_MOD()->GetSdOptions(pDrawDoc->GetDocumentType()) );
}
}
/*************************************************************************
|*
|* Dtor
|*
\************************************************************************/
FrameView::~FrameView()
{
}
/*************************************************************************
|*
|* Verbindung herstellen
|*
\************************************************************************/
void FrameView::Connect()
{
nRefCount++;
}
/*************************************************************************
|*
|* Verbindung loesen
|*
\************************************************************************/
void FrameView::Disconnect()
{
if (nRefCount > 0)
{
nRefCount--;
}
if (nRefCount == 0)
{
delete this;
}
}
/*************************************************************************
|*
|* Inserter fuer SvStream zum Speichern
|*
\************************************************************************/
SvStream& operator << (SvStream& rOut, const FrameView& rView)
{
ULONG nULTemp;
// #95895# translate view-layer name to standard-ASCII
// like in MakeUniqueLayerNames()
String aLayerName(rView.GetActiveLayer());
String aLayerLayout(SdResId(STR_LAYER_LAYOUT));
String aLayerBckgrnd(SdResId(STR_LAYER_BCKGRND));
String aLayerBckgrndObj(SdResId(STR_LAYER_BCKGRNDOBJ));
String aLayerControls(SdResId(STR_LAYER_CONTROLS));
String aLayerMeasurelines(SdResId(STR_LAYER_MEASURELINES));
sal_Bool bActiveLayerWasChanged(sal_False);
String aOldLayerName(rView.GetActiveLayer());
if (aLayerName == aLayerLayout)
{
((FrameView&)rView).SetActiveLayer( String( RTL_CONSTASCII_USTRINGPARAM( "LAYER_LAYOUT" )));
bActiveLayerWasChanged = sal_True;
}
else if (aLayerName == aLayerBckgrnd)
{
((FrameView&)rView).SetActiveLayer( String( RTL_CONSTASCII_USTRINGPARAM( "LAYER_BCKGRND" )));
bActiveLayerWasChanged = sal_True;
}
else if (aLayerName == aLayerBckgrndObj)
{
((FrameView&)rView).SetActiveLayer( String( RTL_CONSTASCII_USTRINGPARAM( "LAYER_BACKGRNDOBJ" )));
bActiveLayerWasChanged = sal_True;
}
else if (aLayerName == aLayerControls)
{
((FrameView&)rView).SetActiveLayer( String( RTL_CONSTASCII_USTRINGPARAM( "LAYER_CONTROLS" )));
bActiveLayerWasChanged = sal_True;
}
else if (aLayerName == aLayerMeasurelines)
{
((FrameView&)rView).SetActiveLayer( String( RTL_CONSTASCII_USTRINGPARAM( "LAYER_MEASURELINES" )));
bActiveLayerWasChanged = sal_True;
}
// stream out the view
rOut << (SdrView&) rView;
// #95895# when active layer name was changed for export, change it back to original here
if(bActiveLayerWasChanged)
{
((FrameView&)rView).SetActiveLayer(aOldLayerName);
}
// Letzter Parameter ist die aktuelle Versionsnummer des Codes
SdIOCompat aIO(rOut, STREAM_WRITE, 11);
rOut << rView.bRuler;
rOut << rView.aVisibleLayers;
rOut << rView.aLockedLayers;
rOut << rView.aPrintableLayers;
rOut << rView.aStandardHelpLines;
rOut << rView.aNotesHelpLines;
rOut << rView.aHandoutHelpLines;
rOut << rView.bNoColors;
rOut << rView.bNoAttribs;
rOut << rView.aVisArea;
nULTemp = (ULONG) rView.ePageKind; rOut << nULTemp;
rOut << rView.nSelectedPage;
nULTemp = (ULONG) rView.eStandardEditMode; rOut << nULTemp;
rOut << rView.bLayerMode;
rOut << rView.bQuickEdit;
rOut << rView.bDragWithCopy;
rOut << (UINT16)rView.nSlidesPerRow;
rOut << rView.bBigHandles;
rOut << rView.bDoubleClickTextEdit;
rOut << rView.bClickChangeRotation;
nULTemp = (ULONG) rView.eNotesEditMode; rOut << nULTemp;
nULTemp = (ULONG) rView.eHandoutEditMode; rOut << nULTemp;
rOut << rView.nDrawMode;
rOut << rView.nPreviewDrawMode;
rOut << rView.bShowPreviewInPageMode;
rOut << rView.bShowPreviewInMasterPageMode;
rOut << rView.bShowPreviewInOutlineMode;
return rOut;
}
/*************************************************************************
|*
|* Extractor fuer SvStream zum Laden
|*
\************************************************************************/
SvStream& operator >> (SvStream& rIn, FrameView& rView)
{
rIn >> (SdrView&) rView;
SdIOCompat aIO(rIn, STREAM_READ);
rIn >> rView.bRuler;
rIn >> rView.aVisibleLayers;
rIn >> rView.aLockedLayers;
rIn >> rView.aPrintableLayers;
rIn >> rView.aStandardHelpLines;
if (aIO.GetVersion() >= 1)
{
// Daten der Versionen >= 1 einlesen
rIn >> rView.aNotesHelpLines;
rIn >> rView.aHandoutHelpLines;
}
if (aIO.GetVersion() >= 2)
{
// Daten der Versionen >= 2 einlesen
rIn >> rView.bNoColors;
rIn >> rView.bNoAttribs;
}
if (aIO.GetVersion() >= 3)
{
ULONG nULTemp;
rIn >> rView.aVisArea;
rIn >> nULTemp; rView.ePageKind = (PageKind) nULTemp;
rIn >> rView.nSelectedPage;
rIn >> nULTemp; rView.eStandardEditMode = (EditMode) nULTemp;
rView.eNotesEditMode = rView.eStandardEditMode;
rView.eHandoutEditMode = rView.eStandardEditMode;
rIn >> rView.bLayerMode;
}
if (aIO.GetVersion() >= 4)
{
rIn >> rView.bQuickEdit;
}
if (aIO.GetVersion() >= 5)
{
rIn >> rView.bDragWithCopy;
}
if (aIO.GetVersion() >= 6)
{
UINT16 nTemp;
rIn >> nTemp; rView.nSlidesPerRow = (USHORT)nTemp;
}
if (aIO.GetVersion() >= 7)
{
rIn >> rView.bBigHandles;
rIn >> rView.bDoubleClickTextEdit;
rIn >> rView.bClickChangeRotation;
}
if (aIO.GetVersion() >= 8)
{
ULONG nULTemp;
rIn >> nULTemp; rView.eNotesEditMode = (EditMode) nULTemp;
rIn >> nULTemp; rView.eHandoutEditMode = (EditMode) nULTemp;
}
if (aIO.GetVersion() >= 9)
{
rIn >> rView.nDrawMode;
rIn >> rView.nPreviewDrawMode;
}
if (aIO.GetVersion() >= 10)
{
rIn >> rView.bShowPreviewInPageMode;
rIn >> rView.bShowPreviewInMasterPageMode;
}
if (aIO.GetVersion() >= 11)
{
rIn >> rView.bShowPreviewInOutlineMode;
}
// Falls die UniqueLayerNames vorhanden sind, werden die Default-Namen
// verwendet
String aLayerName(rView.GetActiveLayer());
if (aLayerName == String( RTL_CONSTASCII_USTRINGPARAM( "LAYER_LAYOUT" )))
{
rView.SetActiveLayer(String(SdResId(STR_LAYER_LAYOUT)));
}
else if (aLayerName == String( RTL_CONSTASCII_USTRINGPARAM( "LAYER_BCKGRND" )))
{
rView.SetActiveLayer(String(SdResId(STR_LAYER_BCKGRND)));
}
else if (aLayerName == String( RTL_CONSTASCII_USTRINGPARAM( "LAYER_BACKGRNDOBJ" )))
{
rView.SetActiveLayer(String(SdResId(STR_LAYER_BCKGRNDOBJ)));
}
else if (aLayerName == String( RTL_CONSTASCII_USTRINGPARAM( "LAYER_CONTROLS" )))
{
rView.SetActiveLayer(String(SdResId(STR_LAYER_CONTROLS)));
}
else if (aLayerName == String( RTL_CONSTASCII_USTRINGPARAM( "LAYER_MEASURELINES" )))
{
rView.SetActiveLayer(String(SdResId(STR_LAYER_MEASURELINES)));
}
if (rView.GetModel())
{
USHORT nMaxPages = ((SdDrawDocument* )rView.GetModel())->
GetSdPageCount(rView.ePageKind);
if (rView.nSelectedPage >= nMaxPages)
{
// Ggf. auf die letzte Seite selektieren
rView.nSelectedPage = nMaxPages - 1;
}
}
return rIn;
}
/*************************************************************************
|*
|* Update mit Daten der SdOptions
|*
\************************************************************************/
void FrameView::Update(SdOptions* pOptions)
{
if (pOptions)
{
bRuler = pOptions->IsRulerVisible();
SetGridVisible( pOptions->IsGridVisible() );
SetSnapAngle( pOptions->GetAngle() );
SetGridSnap( pOptions->IsUseGridSnap() );
SetBordSnap( pOptions->IsSnapBorder() );
SetHlplSnap( pOptions->IsSnapHelplines() );
SetOFrmSnap( pOptions->IsSnapFrame() );
SetOPntSnap( pOptions->IsSnapPoints() );
SetHlplVisible( pOptions->IsHelplines() );
SetDragStripes( pOptions->IsDragStripes() );
SetPlusHandlesAlwaysVisible( pOptions->IsHandlesBezier() );
SetSnapMagneticPixel( pOptions->GetSnapArea() );
SetMarkedHitMovesAlways( pOptions->IsMarkedHitMovesAlways() );
SetMoveOnlyDragging( pOptions->IsMoveOnlyDragging() );
SetSlantButShear( pOptions->IsMoveOnlyDragging() );
SetNoDragXorPolys ( !pOptions->IsMoveOutline() );
SetCrookNoContortion( pOptions->IsCrookNoContortion() );
SetAngleSnapEnabled( pOptions->IsRotate() );
SetBigOrtho( pOptions->IsBigOrtho() );
SetOrtho( pOptions->IsOrtho() );
SetEliminatePolyPointLimitAngle( pOptions->GetEliminatePolyPointLimitAngle() );
SetMasterPagePaintCaching( pOptions->IsMasterPagePaintCaching() );
GetModel()->SetPickThroughTransparentTextFrames( pOptions->IsPickThrough() );
SetLineDraft( pOptions->IsHairlineMode() );
SetFillDraft( pOptions->IsOutlineMode() );
SetTextDraft( pOptions->IsNoText() );
SetGrafDraft( pOptions->IsExternGraphic() );
SetSolidMarkHdl( pOptions->IsSolidMarkHdl() );
SetSolidDragging( pOptions->IsSolidDragging() );
SetGridCoarse( Size( pOptions->GetFldDrawX(), pOptions->GetFldDrawY() ) );
SetGridFine( Size( pOptions->GetFldDivisionX(), pOptions->GetFldDivisionY() ) );
// SetSnapGrid( Size( pOptions->GetFldSnapX(), pOptions->GetFldSnapY() ) );
Fraction aFractX(pOptions->GetFldDrawX(), pOptions->GetFldDrawX() / ( pOptions->GetFldDivisionX() ? pOptions->GetFldDivisionX() : 1 ));
Fraction aFractY(pOptions->GetFldDrawY(), pOptions->GetFldDrawY() / ( pOptions->GetFldDivisionY() ? pOptions->GetFldDivisionY() : 1 ));
SetSnapGridWidth(aFractX, aFractY);
SetQuickEdit(pOptions->IsQuickEdit());
SetDragWithCopy(pOptions->IsDragWithCopy());
SetBigHandles( pOptions->IsBigHandles() );
SetDoubleClickTextEdit( pOptions->IsDoubleClickTextEdit() );
SetClickChangeRotation( pOptions->IsClickChangeRotation() );
SetPreviewDrawMode( pOptions->GetPreviewQuality() );
}
}
/*************************************************************************
|*
|* EditMode (Page oder MasterPage) des Arbeitsmodus setzen
|*
\************************************************************************/
void FrameView::SetViewShEditMode(EditMode eMode, PageKind eKind)
{
if (eKind == PK_STANDARD)
{
eStandardEditMode = eMode;
}
else if (eKind == PK_NOTES)
{
eNotesEditMode = eMode;
}
else if (eKind == PK_HANDOUT)
{
eHandoutEditMode = eMode;
}
}
/*************************************************************************
|*
|* EditMode (Page oder MasterPage) des Arbeitsmodus zurueckgeben
|*
\************************************************************************/
EditMode FrameView::GetViewShEditMode(PageKind eKind)
{
EditMode eMode = EM_PAGE;
if (eKind == PK_STANDARD)
{
eMode = eStandardEditMode;
}
else if (eKind == PK_NOTES)
{
eMode = eNotesEditMode;
}
else if (eKind == PK_HANDOUT)
{
eMode = eHandoutEditMode;
}
return (eMode);
}
static OUString createHelpLinesString( const SdrHelpLineList& rHelpLines )
{
OUStringBuffer aLines;
const USHORT nCount = rHelpLines.GetCount();
for( USHORT nHlpLine = 0; nHlpLine < nCount; nHlpLine++ )
{
const SdrHelpLine& rHelpLine = rHelpLines[nHlpLine];
const Point& rPos = rHelpLine.GetPos();
switch( rHelpLine.GetKind() )
{
case SDRHELPLINE_POINT:
aLines.append( (sal_Unicode)'P' );
aLines.append( (sal_Int32)rPos.X() );
aLines.append( (sal_Unicode)',' );
aLines.append( (sal_Int32)rPos.Y() );
break;
case SDRHELPLINE_VERTICAL:
aLines.append( (sal_Unicode)'V' );
aLines.append( (sal_Int32)rPos.X() );
break;
case SDRHELPLINE_HORIZONTAL:
aLines.append( (sal_Unicode)'H' );
aLines.append( (sal_Int32)rPos.Y() );
break;
default:
DBG_ERROR( "Unsupported helpline Kind!" );
}
}
return aLines.makeStringAndClear();
}
#define addValue( n, v ) push_back( std::pair< OUString, Any >( OUString( RTL_CONSTASCII_USTRINGPARAM( n ) ), v ) )
void FrameView::WriteUserDataSequence ( ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rValues, sal_Bool bBrowse )
{
std::vector< std::pair< OUString, Any > > aUserData;
aUserData.addValue( sUNO_View_GridIsVisible, makeAny( (sal_Bool)IsGridVisible() ) );
aUserData.addValue( sUNO_View_GridIsFront, makeAny( (sal_Bool)IsGridFront() ) );
aUserData.addValue( sUNO_View_IsSnapToGrid, makeAny( (sal_Bool)IsGridSnap() ) );
aUserData.addValue( sUNO_View_IsSnapToPageMargins, makeAny( (sal_Bool)IsBordSnap() ) );
aUserData.addValue( sUNO_View_IsSnapToSnapLines, makeAny( (sal_Bool)IsHlplSnap() ) );
aUserData.addValue( sUNO_View_IsSnapToObjectFrame, makeAny( (sal_Bool)IsOFrmSnap() ) );
aUserData.addValue( sUNO_View_IsSnapToObjectPoints, makeAny( (sal_Bool)IsOPntSnap() ) );
// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsSnapLinesVisible ) );
// pValue->Value <<= (sal_Bool)IsHlplVisible();
// pValue++;nIndex++;
// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsDragStripes ) );
// pValue->Value <<= (sal_Bool)IsDragStripes();
// pValue++;nIndex++;
aUserData.addValue( sUNO_View_IsPlusHandlesAlwaysVisible, makeAny( (sal_Bool)IsPlusHandlesAlwaysVisible() ) );
aUserData.addValue( sUNO_View_IsFrameDragSingles, makeAny( (sal_Bool)IsFrameDragSingles() ) );
// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsMarkedHitMovesAlways ) );
// pValue->Value <<= (sal_Bool)IsMarkedHitMovesAlways();
// pValue++;nIndex++;
aUserData.addValue( sUNO_View_EliminatePolyPointLimitAngle, makeAny( (sal_Int32)GetEliminatePolyPointLimitAngle() ) );
aUserData.addValue( sUNO_View_IsEliminatePolyPoints, makeAny( (sal_Bool)IsEliminatePolyPoints() ) );
// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsLineDraft ) );
// pValue->Value <<= (sal_Bool)IsLineDraft();
// pValue++;nIndex++;
// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsFillDraft ) );
// pValue->Value <<= (sal_Bool)IsFillDraft();
// pValue++;nIndex++;
// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsTextDraft ) );
// pValue->Value <<= (sal_Bool)IsTextDraft();
// pValue++;nIndex++;
// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsGrafDraft ) );
// pValue->Value <<= (sal_Bool)IsGrafDraft();
// pValue++;nIndex++;
Any aAny;
GetVisibleLayers().QueryValue( aAny );
aUserData.addValue( sUNO_View_VisibleLayers, aAny );
GetPrintableLayers().QueryValue( aAny );
aUserData.addValue( sUNO_View_PrintableLayers, aAny );
GetLockedLayers().QueryValue( aAny );
aUserData.addValue( sUNO_View_LockedLayers, aAny );
aUserData.addValue( sUNO_View_NoAttribs, makeAny( (sal_Bool)IsNoAttribs() ) );
aUserData.addValue( sUNO_View_NoColors, makeAny( (sal_Bool)IsNoColors() ) );
if( GetStandardHelpLines().GetCount() )
aUserData.addValue( sUNO_View_SnapLinesDrawing, makeAny( createHelpLinesString( GetStandardHelpLines() ) ) );
if( GetNotesHelpLines().GetCount() )
aUserData.addValue( sUNO_View_SnapLinesNotes, makeAny( createHelpLinesString( GetNotesHelpLines() ) ) );
if( GetHandoutHelpLines().GetCount() )
aUserData.addValue( sUNO_View_SnapLinesHandout, makeAny( createHelpLinesString( GetHandoutHelpLines() ) ) );
aUserData.addValue( sUNO_View_RulerIsVisible, makeAny( (sal_Bool)HasRuler() ) );
aUserData.addValue( sUNO_View_PageKind, makeAny( (sal_Int16)GetPageKind() ) );
aUserData.addValue( sUNO_View_SelectedPage, makeAny( (sal_Int16)GetSelectedPage() ) );
aUserData.addValue( sUNO_View_IsLayerMode, makeAny( (sal_Bool)IsLayerMode() ) );
// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsQuickEdit ) );
// pValue->Value <<= (sal_Bool)IsQuickEdit();
// pValue++;nIndex++;
aUserData.addValue( sUNO_View_IsBigHandles, makeAny( (sal_Bool)IsBigHandles() ) );
aUserData.addValue( sUNO_View_IsDoubleClickTextEdit, makeAny( (sal_Bool)IsDoubleClickTextEdit() ) );
aUserData.addValue( sUNO_View_IsClickChangeRotation, makeAny( (sal_Bool)IsClickChangeRotation() ) );
// pValue->Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( sUNO_View_IsDragWithCopy ) );
// pValue->Value <<= (sal_Bool)IsDragWithCopy();
// pValue++;nIndex++;
aUserData.addValue( sUNO_View_SlidesPerRow, makeAny( (sal_Int16)GetSlidesPerRow() ) );
aUserData.addValue( sUNO_View_DrawMode, makeAny( (sal_Int32)GetDrawMode() ) );
aUserData.addValue( sUNO_View_PreviewDrawMode, makeAny( (sal_Int32)GetPreviewDrawMode() ) );
aUserData.addValue( sUNO_View_IsShowPreviewInPageMode, makeAny( (sal_Bool)IsShowPreviewInPageMode() ) );
aUserData.addValue( sUNO_View_IsShowPreviewInMasterPageMode, makeAny( (sal_Bool)IsShowPreviewInMasterPageMode() ) );
aUserData.addValue( sUNO_View_SetShowPreviewInOutlineMode, makeAny( (sal_Bool)IsShowPreviewInOutlineMode() ) );
aUserData.addValue( sUNO_View_EditModeStandard, makeAny( (sal_Int32)GetViewShEditMode( PK_STANDARD ) ) );
aUserData.addValue( sUNO_View_EditModeNotes, makeAny( (sal_Int32)GetViewShEditMode( PK_NOTES ) ) );
aUserData.addValue( sUNO_View_EditModeHandout, makeAny( (sal_Int32)GetViewShEditMode( PK_HANDOUT ) ) );
{
const Rectangle aVisArea = GetVisArea();
aUserData.addValue( sUNO_View_VisibleAreaTop, makeAny( (sal_Int32)aVisArea.Top() ) );
aUserData.addValue( sUNO_View_VisibleAreaLeft, makeAny( (sal_Int32)aVisArea.Left() ) );
aUserData.addValue( sUNO_View_VisibleAreaWidth, makeAny( (sal_Int32)aVisArea.GetWidth() ) );
aUserData.addValue( sUNO_View_VisibleAreaHeight, makeAny( (sal_Int32)aVisArea.GetHeight() ) );
}
aUserData.addValue( sUNO_View_GridCoarseWidth, makeAny( (sal_Int32)GetGridCoarse().Width() ) );
aUserData.addValue( sUNO_View_GridCoarseHeight, makeAny( (sal_Int32)GetGridCoarse().Height() ) );
aUserData.addValue( sUNO_View_GridFineWidth, makeAny( (sal_Int32)GetGridFine().Width() ) );
aUserData.addValue( sUNO_View_GridFineHeight, makeAny( (sal_Int32)GetGridFine().Height() ) );
aUserData.addValue( sUNO_View_GridSnapWidth, makeAny( (sal_Int32)GetSnapGrid().Width() ) );
aUserData.addValue( sUNO_View_GridSnapHeight, makeAny( (sal_Int32)GetSnapGrid().Height() ) );
aUserData.addValue( sUNO_View_GridSnapWidthXNumerator, makeAny( (sal_Int32)GetSnapGridWidthX().GetNumerator() ) );
aUserData.addValue( sUNO_View_GridSnapWidthXDenominator, makeAny( (sal_Int32)GetSnapGridWidthX().GetDenominator() ) );
aUserData.addValue( sUNO_View_GridSnapWidthYNumerator, makeAny( (sal_Int32)GetSnapGridWidthY().GetNumerator() ) );
aUserData.addValue( sUNO_View_GridSnapWidthYDenominator, makeAny( (sal_Int32)GetSnapGridWidthY().GetDenominator() ) );
aUserData.addValue( sUNO_View_IsAngleSnapEnabled, makeAny( (sal_Bool)IsAngleSnapEnabled() ) );
aUserData.addValue( sUNO_View_SnapAngle, makeAny( (sal_Int32)GetSnapAngle() ) );
const sal_Int32 nOldLength = rValues.getLength();
rValues.realloc( nOldLength + aUserData.size() );
PropertyValue* pValue = &(rValues.getArray()[nOldLength]);
std::vector< std::pair< OUString, Any > >::iterator aIter( aUserData.begin() );
for( ; aIter != aUserData.end(); aIter++, pValue++ )
{
pValue->Name = (*aIter).first;
pValue->Value = (*aIter).second;
}
}
#undef addValue
static void createHelpLinesFromString( const rtl::OUString& rLines, SdrHelpLineList& rHelpLines )
{
const sal_Unicode * pStr = rLines.getStr();
SdrHelpLine aNewHelpLine;
rtl::OUStringBuffer sBuffer;
while( *pStr )
{
Point aPoint;
switch( *pStr )
{
case (sal_Unicode)'P':
aNewHelpLine.SetKind( SDRHELPLINE_POINT );
break;
case (sal_Unicode)'V':
aNewHelpLine.SetKind( SDRHELPLINE_VERTICAL );
break;
case (sal_Unicode)'H':
aNewHelpLine.SetKind( SDRHELPLINE_HORIZONTAL );
break;
default:
DBG_ERROR( "syntax error in snap lines settings string" );
return;
}
pStr++;
while( (*pStr >= sal_Unicode('0') && *pStr <= sal_Unicode('9')) || (*pStr == '+') || (*pStr == '-') )
{
sBuffer.append( *pStr++ );
}
sal_Int32 nValue = sBuffer.makeStringAndClear().toInt32();
if( aNewHelpLine.GetKind() == SDRHELPLINE_HORIZONTAL )
{
aPoint.Y() = nValue;
}
else
{
aPoint.X() = nValue;
if( aNewHelpLine.GetKind() == SDRHELPLINE_POINT )
{
if( *pStr++ != ',' )
return;
while( (*pStr >= sal_Unicode('0') && *pStr <= sal_Unicode('9')) || (*pStr == '+') || (*pStr == '-') )
{
sBuffer.append( *pStr++ );
}
aPoint.Y() = sBuffer.makeStringAndClear().toInt32();
}
}
aNewHelpLine.SetPos( aPoint );
rHelpLines.Insert( aNewHelpLine );
}
}
void FrameView::ReadUserDataSequence ( const ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rSequence, sal_Bool bBrowse )
{
const sal_Int32 nLength = rSequence.getLength();
if (nLength)
{
sal_Bool bBool;
sal_Int32 nInt32;
sal_Int16 nInt16;
rtl::OUString aString;
sal_Int32 aSnapGridWidthXNum = GetSnapGridWidthX().GetNumerator();
sal_Int32 aSnapGridWidthXDom = GetSnapGridWidthX().GetDenominator();
sal_Int32 aSnapGridWidthYNum = GetSnapGridWidthY().GetNumerator();
sal_Int32 aSnapGridWidthYDom = GetSnapGridWidthY().GetDenominator();
const com::sun::star::beans::PropertyValue *pValue = rSequence.getConstArray();
for (sal_Int16 i = 0 ; i < nLength; i++, pValue++ )
{
if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_ViewId ) ) )
{
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapLinesDrawing ) ) )
{
if( pValue->Value >>= aString )
{
SdrHelpLineList aHelpLines;
createHelpLinesFromString( aString, aHelpLines );
SetStandardHelpLines( aHelpLines );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapLinesNotes ) ) )
{
if( pValue->Value >>= aString )
{
SdrHelpLineList aHelpLines;
createHelpLinesFromString( aString, aHelpLines );
SetNotesHelpLines( aHelpLines );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapLinesHandout ) ) )
{
if( pValue->Value >>= aString )
{
SdrHelpLineList aHelpLines;
createHelpLinesFromString( aString, aHelpLines );
SetHandoutHelpLines( aHelpLines );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_RulerIsVisible ) ) )
{
if( pValue->Value >>= bBool )
{
SetRuler( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_PageKind ) ) )
{
if( pValue->Value >>= nInt16 )
{
SetPageKind( (PageKind)nInt16 );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SelectedPage ) ) )
{
if( pValue->Value >>= nInt16 )
{
SetSelectedPage( (USHORT)nInt16 );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsLayerMode ) ) )
{
if( pValue->Value >>= bBool )
{
SetLayerMode( bBool );
}
}
/* else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsQuickEdit ) ) )
{
if( pValue->Value >>= bBool )
{
SetQuickEdit( bBool );
}
}
*/ else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsBigHandles ) ) )
{
if( pValue->Value >>= bBool )
{
SetBigHandles( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsDoubleClickTextEdit ) ) )
{
if( pValue->Value >>= bBool )
{
SetDoubleClickTextEdit( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsClickChangeRotation ) ) )
{
if( pValue->Value >>= bBool )
{
SetClickChangeRotation( bBool );
}
}
/* else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsDragWithCopy ) ) )
{
if( pValue->Value >>= bBool )
{
SetDragWithCopy( bBool );
}
}
*/ else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SlidesPerRow ) ) )
{
if( pValue->Value >>= nInt16 )
{
SetSlidesPerRow( (USHORT)nInt16 );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_DrawMode ) ) )
{
if( pValue->Value >>= nInt32 )
{
const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
SvtAccessibilityOptions aAccOptions;
if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForDrawings() )
continue;
SetDrawMode( (ULONG)nInt32 );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_PreviewDrawMode ) ) )
{
if( pValue->Value >>= nInt32 )
{
const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
SvtAccessibilityOptions aAccOptions;
if( rStyleSettings.GetHighContrastMode() && aAccOptions.GetIsForPagePreviews() )
continue;
SetPreviewDrawMode( (ULONG)nInt32 );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsShowPreviewInPageMode ) ) )
{
if( pValue->Value >>= bBool )
{
SetShowPreviewInPageMode( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsShowPreviewInMasterPageMode ) ) )
{
if( pValue->Value >>= bBool )
{
SetShowPreviewInMasterPageMode( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SetShowPreviewInOutlineMode ) ) )
{
if( pValue->Value >>= bBool )
{
SetShowPreviewInOutlineMode( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EditModeStandard ) ) )
{
if( pValue->Value >>= nInt32 )
{
SetViewShEditMode( (EditMode)nInt32, PK_STANDARD );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EditModeNotes ) ) )
{
if( pValue->Value >>= nInt32 )
{
SetViewShEditMode( (EditMode)nInt32, PK_NOTES );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EditModeHandout ) ) )
{
if( pValue->Value >>= nInt32 )
{
SetViewShEditMode( (EditMode)nInt32, PK_HANDOUT );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaTop ) ) )
{
sal_Int32 nTop;
if( pValue->Value >>= nTop )
{
Rectangle aVisArea( GetVisArea() );
aVisArea.nBottom += nTop - aVisArea.nTop;
aVisArea.nTop = nTop;
SetVisArea( aVisArea );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaLeft ) ) )
{
sal_Int32 nLeft;
if( pValue->Value >>= nLeft )
{
Rectangle aVisArea( GetVisArea() );
aVisArea.nRight += nLeft - aVisArea.nLeft;
aVisArea.nLeft = nLeft;
SetVisArea( aVisArea );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaWidth ) ) )
{
sal_Int32 nWidth;
if( pValue->Value >>= nWidth )
{
Rectangle aVisArea( GetVisArea() );
aVisArea.nRight = aVisArea.nLeft + nWidth - 1;
SetVisArea( aVisArea );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleAreaHeight ) ) )
{
sal_Int32 nHeight;
if( pValue->Value >>= nHeight )
{
Rectangle aVisArea( GetVisArea() );
aVisArea.nBottom = nHeight + aVisArea.nTop - 1;
SetVisArea( aVisArea );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridIsVisible ) ) )
{
if( pValue->Value >>= bBool )
{
SetGridVisible( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToGrid ) ) )
{
if( pValue->Value >>= bBool )
{
SetGridSnap( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridIsFront ) ) )
{
if( pValue->Value >>= bBool )
{
SetGridFront( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToPageMargins ) ) )
{
if( pValue->Value >>= bBool )
{
SetBordSnap( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToSnapLines ) ) )
{
if( pValue->Value >>= bBool )
{
SetHlplSnap( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToObjectFrame ) ) )
{
if( pValue->Value >>= bBool )
{
SetOFrmSnap( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapToObjectPoints ) ) )
{
if( pValue->Value >>= bBool )
{
SetOPntSnap( bBool );
}
}
/* else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsSnapLinesVisible ) ) )
{
if( pValue->Value >>= bBool )
{
SetHlplVisible( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsDragStripes ) ) )
{
if( pValue->Value >>= bBool )
{
SetDragStripes( bBool );
}
}
*/ else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsPlusHandlesAlwaysVisible ) ) )
{
if( pValue->Value >>= bBool )
{
SetPlusHandlesAlwaysVisible( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsFrameDragSingles ) ) )
{
if( pValue->Value >>= bBool )
{
SetFrameDragSingles( bBool );
}
}
/* else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsMarkedHitMovesAlways ) ) )
{
if( pValue->Value >>= bBool )
{
SetMarkedHitMovesAlways( bBool );
}
}
*/ else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_EliminatePolyPointLimitAngle ) ) )
{
if( pValue->Value >>= nInt32 )
{
SetEliminatePolyPointLimitAngle( nInt32 );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsEliminatePolyPoints ) ) )
{
if( pValue->Value >>= bBool )
{
SetEliminatePolyPoints( bBool );
}
}
/*
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsLineDraft ) ) )
{
if( pValue->Value >>= bBool )
{
SetLineDraft( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsFillDraft ) ) )
{
if( pValue->Value >>= bBool )
{
SetFillDraft( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsTextDraft ) ) )
{
if( pValue->Value >>= bBool )
{
SetTextDraft( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsGrafDraft ) ) )
{
if( pValue->Value >>= bBool )
{
SetGrafDraft( bBool );
}
}
*/
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_ActiveLayer ) ) )
{
if( pValue->Value >>= aString )
{
SetActiveLayer( aString );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_NoAttribs ) ) )
{
if( pValue->Value >>= bBool )
{
SetNoAttribs( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_NoColors ) ) )
{
if( pValue->Value >>= bBool )
{
SetNoColors( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridCoarseWidth ) ) )
{
if( pValue->Value >>= nInt32 )
{
const Size aCoarse( nInt32, GetGridCoarse().Height() );
SetGridCoarse( aCoarse );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridCoarseHeight ) ) )
{
if( pValue->Value >>= nInt32 )
{
const Size aCoarse( GetGridCoarse().Width(), nInt32 );
SetGridCoarse( aCoarse );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridFineWidth ) ) )
{
if( pValue->Value >>= nInt32 )
{
const Size aCoarse( nInt32, GetGridFine().Height() );
SetGridFine( aCoarse );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridFineHeight ) ) )
{
if( pValue->Value >>= nInt32 )
{
const Size aCoarse( GetGridFine().Width(), nInt32 );
SetGridFine( aCoarse );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidth ) ) )
{
if( pValue->Value >>= nInt32 )
{
const Size aCoarse( nInt32, GetSnapGrid().Height() );
SetSnapGrid( aCoarse );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapHeight ) ) )
{
if( pValue->Value >>= nInt32 )
{
const Size aCoarse( GetSnapGrid().Width(), nInt32 );
SetSnapGrid( aCoarse );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_IsAngleSnapEnabled ) ) )
{
if( pValue->Value >>= bBool )
{
SetAngleSnapEnabled( bBool );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_SnapAngle ) ) )
{
if( pValue->Value >>= nInt32 )
{
SetSnapAngle( nInt32 );
}
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthXNumerator ) ) )
{
pValue->Value >>= aSnapGridWidthXNum;
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthXDenominator ) ) )
{
pValue->Value >>= aSnapGridWidthXDom;
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthYNumerator ) ) )
{
pValue->Value >>= aSnapGridWidthYNum;
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_GridSnapWidthYDenominator ) ) )
{
pValue->Value >>= aSnapGridWidthYDom;
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_VisibleLayers ) ) )
{
SetOfByte aSetOfBytes;
aSetOfBytes.PutValue( pValue->Value );
SetVisibleLayers( aSetOfBytes );
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_PrintableLayers ) ) )
{
SetOfByte aSetOfBytes;
aSetOfBytes.PutValue( pValue->Value );
SetPrintableLayers( aSetOfBytes );
}
else if (pValue->Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( sUNO_View_LockedLayers ) ) )
{
SetOfByte aSetOfBytes;
aSetOfBytes.PutValue( pValue->Value );
SetLockedLayers( aSetOfBytes );
}
}
const Fraction aSnapGridWidthX( aSnapGridWidthXNum, aSnapGridWidthXDom );
const Fraction aSnapGridWidthY( aSnapGridWidthYNum, aSnapGridWidthYDom );
SetSnapGridWidth( aSnapGridWidthX, aSnapGridWidthY );
}
}