drawinglayer/source/geometry/viewinformation3d.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include <drawinglayer/geometry/viewinformation3d.hxx>
  30 #include <basegfx/range/b3drange.hxx>
  31 #include <basegfx/matrix/b3dhommatrix.hxx>
  32 #include <com/sun/star/geometry/AffineMatrix3D.hpp>
  33 #include <com/sun/star/geometry/RealRectangle3D.hpp>
  34 #include <basegfx/tools/canvastools.hxx>
  35
  36 //////////////////////////////////////////////////////////////////////////////
  37
  38 using namespace com::sun::star;
  39
  40 //////////////////////////////////////////////////////////////////////////////
  41
  42 namespace drawinglayer
  43 {
  44     namespace geometry
  45     {
  46         /** Implementation class for ViewInformation3D
  47         */
  48         class ImpViewInformation3D
  49         {
  50         private:
  51             // ViewInformation3D implementation can change refcount, so we have only
  52             // two memory regions for pairs of ViewInformation3D/ImpViewInformation3D
  53             friend class ::drawinglayer::geometry::ViewInformation3D;
  54
  55             // the refcounter. 0 means exclusively used
  56             sal_uInt32                                  mnRefCount;
  57
  58             // the 3D transformations
  59             // Object to World. This may change and being adapted when entering 3D transformation
  60             // groups
  61             basegfx::B3DHomMatrix                       maObjectTransformation;
  62
  63             // World to Camera. This includes VRP, VPN and VUV camera coordinate system
  64             basegfx::B3DHomMatrix                       maOrientation;
  65
  66             // Camera to Device with X,Y and Z [-1.0 .. 1.0]. This is the
  67             // 3D to 2D projection which may be parallell or perspective. When it is perspective,
  68             // the last line of the homogen matrix will NOT be unused
  69             basegfx::B3DHomMatrix                       maProjection;
  70
  71             // Device to View with X,Y and Z [0.0 .. 1.0]. This converts from -1 to 1 coordinates
  72             // in camera coordinate system to 0 to 1 in unit 2D coordinates. This way it stays
  73             // view-independent. To get discrete coordinates, the 2D transformation of a scene
  74             // as 2D object needs to be involved
  75             basegfx::B3DHomMatrix                       maDeviceToView;
  76
  77             // Object to View is the linear combination of all four transformations. It's
  78             // buffered to avoid too much matrix multiplying and created on demand
  79             basegfx::B3DHomMatrix                       maObjectToView;
  80
  81             // the point in time
  82             double                                      mfViewTime;
  83
  84             // the complete PropertyValue representation (if already created)
  85             uno::Sequence< beans::PropertyValue >       mxViewInformation;
  86
  87             // the extra PropertyValues; does not contain the transformations
  88             uno::Sequence< beans::PropertyValue >       mxExtendedInformation;
  89
  90             // the local UNO API strings
  91             const ::rtl::OUString& getNamePropertyObjectTransformation()
  92             {
  93                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("ObjectTransformation"));
  94                 return s_sNameProperty;
  95             }
  96
  97             const ::rtl::OUString& getNamePropertyOrientation()
  98             {
  99                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Orientation"));
 100                 return s_sNameProperty;
 101             }
 102
 103             const ::rtl::OUString& getNamePropertyProjection()
 104             {
 105                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Projection"));
 106                 return s_sNameProperty;
 107             }
 108
 109             const ::rtl::OUString& getNamePropertyProjection_30()
 110             {
 111                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Projection30"));
 112                 return s_sNameProperty;
 113             }
 114
 115             const ::rtl::OUString& getNamePropertyProjection_31()
 116             {
 117                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Projection31"));
 118                 return s_sNameProperty;
 119             }
 120
 121             const ::rtl::OUString& getNamePropertyProjection_32()
 122             {
 123                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Projection32"));
 124                 return s_sNameProperty;
 125             }
 126
 127             const ::rtl::OUString& getNamePropertyProjection_33()
 128             {
 129                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Projection33"));
 130                 return s_sNameProperty;
 131             }
 132
 133             const ::rtl::OUString& getNamePropertyDeviceToView()
 134             {
 135                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("DeviceToView"));
 136                 return s_sNameProperty;
 137             }
 138
 139             const ::rtl::OUString& getNamePropertyTime()
 140             {
 141                 static ::rtl::OUString s_sNamePropertyTime(RTL_CONSTASCII_USTRINGPARAM("Time"));
 142                 return s_sNamePropertyTime;
 143             }
 144
 145             // a central PropertyValue parsing method to allow transportatin of
 146             // all ViewParameters using UNO API
 147             void impInterpretPropertyValues(const uno::Sequence< beans::PropertyValue >& rViewParameters)
 148             {
 149                 if(rViewParameters.hasElements())
 150                 {
 151                     const sal_Int32 nCount(rViewParameters.getLength());
 152                     sal_Int32 nExtendedInsert(0);
 153
 154                     // prepare extended information for filtering. Maximum size is nCount
 155                     mxExtendedInformation.realloc(nCount);
 156
 157                     for(sal_Int32 a(0); a < nCount; a++)
 158                     {
 159                         const beans::PropertyValue& rProp = rViewParameters[a];
 160
 161                         if(rProp.Name == getNamePropertyObjectTransformation())
 162                         {
 163                             com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 164                             rProp.Value >>= aAffineMatrix3D;
 165                             maObjectTransformation = basegfx::unotools::homMatrixFromAffineMatrix3D(aAffineMatrix3D);
 166                         }
 167                         else if(rProp.Name == getNamePropertyOrientation())
 168                         {
 169                             com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 170                             rProp.Value >>= aAffineMatrix3D;
 171                             maOrientation = basegfx::unotools::homMatrixFromAffineMatrix3D(aAffineMatrix3D);
 172                         }
 173                         else if(rProp.Name == getNamePropertyProjection())
 174                         {
 175                             // projection may be defined using a frustum in which case the last line of
 176                             // the 4x4 matrix is not (0,0,0,1). Since AffineMatrix3D does not support that,
 177                             // these four values need to be treated extra
 178                             const double f_30(maProjection.get(3, 0));
 179                             const double f_31(maProjection.get(3, 1));
 180                             const double f_32(maProjection.get(3, 2));
 181                             const double f_33(maProjection.get(3, 3));
 182
 183                             com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 184                             rProp.Value >>= aAffineMatrix3D;
 185                             maProjection = basegfx::unotools::homMatrixFromAffineMatrix3D(aAffineMatrix3D);
 186
 187                             maProjection.set(3, 0, f_30);
 188                             maProjection.set(3, 1, f_31);
 189                             maProjection.set(3, 2, f_32);
 190                             maProjection.set(3, 3, f_33);
 191                         }
 192                         else if(rProp.Name == getNamePropertyProjection_30())
 193                         {
 194                             double f_30(0.0);
 195                             rProp.Value >>= f_30;
 196                             maProjection.set(3, 0, f_30);
 197                         }
 198                         else if(rProp.Name == getNamePropertyProjection_31())
 199                         {
 200                             double f_31(0.0);
 201                             rProp.Value >>= f_31;
 202                             maProjection.set(3, 1, f_31);
 203                         }
 204                         else if(rProp.Name == getNamePropertyProjection_32())
 205                         {
 206                             double f_32(0.0);
 207                             rProp.Value >>= f_32;
 208                             maProjection.set(3, 2, f_32);
 209                         }
 210                         else if(rProp.Name == getNamePropertyProjection_33())
 211                         {
 212                             double f_33(1.0);
 213                             rProp.Value >>= f_33;
 214                             maProjection.set(3, 3, f_33);
 215                         }
 216                         else if(rProp.Name == getNamePropertyDeviceToView())
 217                         {
 218                             com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 219                             rProp.Value >>= aAffineMatrix3D;
 220                             maDeviceToView = basegfx::unotools::homMatrixFromAffineMatrix3D(aAffineMatrix3D);
 221                         }
 222                         else if(rProp.Name == getNamePropertyTime())
 223                         {
 224                             rProp.Value >>= mfViewTime;
 225                         }
 226                         else
 227                         {
 228                             // extra information; add to filtered information
 229                             mxExtendedInformation[nExtendedInsert++] = rProp;
 230                         }
 231                     }
 232
 233                     // extra information size is now known; realloc to final size
 234                     mxExtendedInformation.realloc(nExtendedInsert);
 235                 }
 236             }
 237
 238             // central method to create a Sequence of PropertyValues containing he complete
 239             // data set
 240             void impFillViewInformationFromContent()
 241             {
 242                 uno::Sequence< beans::PropertyValue > xRetval;
 243                 const bool bObjectTransformationUsed(!maObjectTransformation.isIdentity());
 244                 const bool bOrientationUsed(!maOrientation.isIdentity());
 245                 const bool bProjectionUsed(!maProjection.isIdentity());
 246                 const bool bDeviceToViewUsed(!maDeviceToView.isIdentity());
 247                 const bool bTimeUsed(0.0 < mfViewTime);
 248                 const bool bExtraInformation(mxExtendedInformation.hasElements());
 249
 250                 // projection may be defined using a frustum in which case the last line of
 251                 // the 4x4 matrix is not (0,0,0,1). Since AffineMatrix3D does not support that,
 252                 // these four values need to be treated extra
 253                 const bool bProjectionUsed_30(bProjectionUsed && !basegfx::fTools::equalZero(maProjection.get(3, 0)));
 254                 const bool bProjectionUsed_31(bProjectionUsed && !basegfx::fTools::equalZero(maProjection.get(3, 1)));
 255                 const bool bProjectionUsed_32(bProjectionUsed && !basegfx::fTools::equalZero(maProjection.get(3, 2)));
 256                 const bool bProjectionUsed_33(bProjectionUsed && !basegfx::fTools::equal(maProjection.get(3, 3), 1.0));
 257
 258                 sal_uInt32 nIndex(0);
 259                 const sal_uInt32 nCount(
 260                     (bObjectTransformationUsed ? 1 : 0) +
 261                     (bOrientationUsed ? 1 : 0) +
 262                     (bProjectionUsed ? 1 : 0) +
 263                     (bProjectionUsed_30 ? 1 : 0) +
 264                     (bProjectionUsed_31 ? 1 : 0) +
 265                     (bProjectionUsed_32 ? 1 : 0) +
 266                     (bProjectionUsed_33 ? 1 : 0) +
 267                     (bDeviceToViewUsed ? 1 : 0) +
 268                     (bTimeUsed ? 1 : 0) +
 269                     (bExtraInformation ? mxExtendedInformation.getLength() : 0));
 270
 271                 mxViewInformation.realloc(nCount);
 272
 273                 if(bObjectTransformationUsed)
 274                 {
 275                     com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 276                     basegfx::unotools::affineMatrixFromHomMatrix3D(aAffineMatrix3D, maObjectTransformation);
 277                     mxViewInformation[nIndex].Name = getNamePropertyObjectTransformation();
 278                     mxViewInformation[nIndex].Value <<= aAffineMatrix3D;
 279                     nIndex++;
 280                 }
 281
 282                 if(bOrientationUsed)
 283                 {
 284                     com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 285                     basegfx::unotools::affineMatrixFromHomMatrix3D(aAffineMatrix3D, maOrientation);
 286                     mxViewInformation[nIndex].Name = getNamePropertyOrientation();
 287                     mxViewInformation[nIndex].Value <<= aAffineMatrix3D;
 288                     nIndex++;
 289                 }
 290
 291                 if(bProjectionUsed)
 292                 {
 293                     com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 294                     basegfx::unotools::affineMatrixFromHomMatrix3D(aAffineMatrix3D, maProjection);
 295                     mxViewInformation[nIndex].Name = getNamePropertyProjection();
 296                     mxViewInformation[nIndex].Value <<= aAffineMatrix3D;
 297                     nIndex++;
 298                 }
 299
 300                 if(bProjectionUsed_30)
 301                 {
 302                     mxViewInformation[nIndex].Name = getNamePropertyProjection_30();
 303                     mxViewInformation[nIndex].Value <<= maProjection.get(3, 0);
 304                     nIndex++;
 305                 }
 306
 307                 if(bProjectionUsed_31)
 308                 {
 309                     mxViewInformation[nIndex].Name = getNamePropertyProjection_31();
 310                     mxViewInformation[nIndex].Value <<= maProjection.get(3, 1);
 311                     nIndex++;
 312                 }
 313
 314                 if(bProjectionUsed_32)
 315                 {
 316                     mxViewInformation[nIndex].Name = getNamePropertyProjection_32();
 317                     mxViewInformation[nIndex].Value <<= maProjection.get(3, 2);
 318                     nIndex++;
 319                 }
 320
 321                 if(bProjectionUsed_33)
 322                 {
 323                     mxViewInformation[nIndex].Name = getNamePropertyProjection_33();
 324                     mxViewInformation[nIndex].Value <<= maProjection.get(3, 3);
 325                     nIndex++;
 326                 }
 327
 328                 if(bDeviceToViewUsed)
 329                 {
 330                     com::sun::star::geometry::AffineMatrix3D aAffineMatrix3D;
 331                     basegfx::unotools::affineMatrixFromHomMatrix3D(aAffineMatrix3D, maDeviceToView);
 332                     mxViewInformation[nIndex].Name = getNamePropertyDeviceToView();
 333                     mxViewInformation[nIndex].Value <<= aAffineMatrix3D;
 334                     nIndex++;
 335                 }
 336
 337                 if(bTimeUsed)
 338                 {
 339                     mxViewInformation[nIndex].Name = getNamePropertyTime();
 340                     mxViewInformation[nIndex].Value <<= mfViewTime;
 341                     nIndex++;
 342                 }
 343
 344                 if(bExtraInformation)
 345                 {
 346                     const sal_Int32 nExtra(mxExtendedInformation.getLength());
 347
 348                     for(sal_Int32 a(0); a < nExtra; a++)
 349                     {
 350                         mxViewInformation[nIndex++] = mxExtendedInformation[a];
 351                     }
 352                 }
 353             }
 354
 355         public:
 356             ImpViewInformation3D(
 357                 const basegfx::B3DHomMatrix& rObjectTransformation,
 358                 const basegfx::B3DHomMatrix& rOrientation,
 359                 const basegfx::B3DHomMatrix& rProjection,
 360                 const basegfx::B3DHomMatrix& rDeviceToView,
 361                 double fViewTime,
 362                 const uno::Sequence< beans::PropertyValue >& rExtendedParameters)
 363             :   mnRefCount(0),
 364                 maObjectTransformation(rObjectTransformation),
 365                 maOrientation(rOrientation),
 366                 maProjection(rProjection),
 367                 maDeviceToView(rDeviceToView),
 368                 mfViewTime(fViewTime),
 369                 mxViewInformation(),
 370                 mxExtendedInformation()
 371             {
 372                 impInterpretPropertyValues(rExtendedParameters);
 373             }
 374
 375             ImpViewInformation3D(const uno::Sequence< beans::PropertyValue >& rViewParameters)
 376             :   mnRefCount(0),
 377                 maObjectTransformation(),
 378                 maOrientation(),
 379                 maProjection(),
 380                 maDeviceToView(),
 381                 mfViewTime(),
 382                 mxViewInformation(rViewParameters),
 383                 mxExtendedInformation()
 384             {
 385                 impInterpretPropertyValues(rViewParameters);
 386             }
 387
 388             ImpViewInformation3D()
 389             :   mnRefCount(0),
 390                 maObjectTransformation(),
 391                 maOrientation(),
 392                 maProjection(),
 393                 maDeviceToView(),
 394                 mfViewTime(),
 395                 mxViewInformation(),
 396                 mxExtendedInformation()
 397             {
 398             }
 399
 400             const basegfx::B3DHomMatrix& getObjectTransformation() const { return maObjectTransformation; }
 401             const basegfx::B3DHomMatrix& getOrientation() const { return maOrientation; }
 402             const basegfx::B3DHomMatrix& getProjection() const { return maProjection; }
 403             const basegfx::B3DHomMatrix& getDeviceToView() const { return maDeviceToView; }
 404             double getViewTime() const { return mfViewTime; }
 405
 406             const basegfx::B3DHomMatrix& getObjectToView() const
 407             {
 408                 // on demand WorldToView creation
 409                 ::osl::Mutex m_mutex;
 410
 411                 if(maObjectToView.isIdentity())
 412                 {
 413                     const_cast< ImpViewInformation3D* >(this)->maObjectToView = maDeviceToView * maProjection * maOrientation * maObjectTransformation;
 414                 }
 415
 416                 return maObjectToView;
 417             }
 418
 419             const uno::Sequence< beans::PropertyValue >& getViewInformationSequence() const
 420             {
 421                 ::osl::Mutex m_mutex;
 422
 423                 if(!mxViewInformation.hasElements())
 424                 {
 425                     const_cast< ImpViewInformation3D* >(this)->impFillViewInformationFromContent();
 426                 }
 427
 428                 return mxViewInformation;
 429             }
 430
 431             const uno::Sequence< beans::PropertyValue >& getExtendedInformationSequence() const
 432             {
 433                 return mxExtendedInformation;
 434             }
 435
 436             bool operator==(const ImpViewInformation3D& rCandidate) const
 437             {
 438                 return (maObjectTransformation == rCandidate.maObjectTransformation
 439                     && maOrientation == rCandidate.maOrientation
 440                     && maProjection == rCandidate.maProjection
 441                     && maDeviceToView == rCandidate.maDeviceToView
 442                     && mfViewTime == rCandidate.mfViewTime
 443                     && mxExtendedInformation == rCandidate.mxExtendedInformation);
 444             }
 445
 446             static ImpViewInformation3D* get_global_default()
 447             {
 448                 static ImpViewInformation3D* pDefault = 0;
 449
 450                 if(!pDefault)
 451                 {
 452                     pDefault = new ImpViewInformation3D();
 453
 454                     // never delete; start with RefCount 1, not 0
 455                     pDefault->mnRefCount++;
 456                 }
 457
 458                 return pDefault;
 459             }
 460         };
 461     } // end of anonymous namespace
 462 } // end of namespace drawinglayer
 463
 464 //////////////////////////////////////////////////////////////////////////////
 465
 466 namespace drawinglayer
 467 {
 468     namespace geometry
 469     {
 470         ViewInformation3D::ViewInformation3D(
 471             const basegfx::B3DHomMatrix& rObjectObjectTransformation,
 472             const basegfx::B3DHomMatrix& rOrientation,
 473             const basegfx::B3DHomMatrix& rProjection,
 474             const basegfx::B3DHomMatrix& rDeviceToView,
 475             double fViewTime,
 476             const uno::Sequence< beans::PropertyValue >& rExtendedParameters)
 477         :   mpViewInformation3D(new ImpViewInformation3D(
 478                 rObjectObjectTransformation, rOrientation, rProjection,
 479                 rDeviceToView, fViewTime, rExtendedParameters))
 480         {
 481         }
 482
 483         ViewInformation3D::ViewInformation3D(const uno::Sequence< beans::PropertyValue >& rViewParameters)
 484         :   mpViewInformation3D(new ImpViewInformation3D(rViewParameters))
 485         {
 486         }
 487
 488         ViewInformation3D::ViewInformation3D()
 489         :   mpViewInformation3D(ImpViewInformation3D::get_global_default())
 490         {
 491             mpViewInformation3D->mnRefCount++;
 492         }
 493
 494         ViewInformation3D::ViewInformation3D(const ViewInformation3D& rCandidate)
 495         :   mpViewInformation3D(rCandidate.mpViewInformation3D)
 496         {
 497             ::osl::Mutex m_mutex;
 498             mpViewInformation3D->mnRefCount++;
 499         }
 500
 501         ViewInformation3D::~ViewInformation3D()
 502         {
 503             ::osl::Mutex m_mutex;
 504
 505             if(mpViewInformation3D->mnRefCount)
 506             {
 507                 mpViewInformation3D->mnRefCount--;
 508             }
 509             else
 510             {
 511                 delete mpViewInformation3D;
 512             }
 513         }
 514
 515         bool ViewInformation3D::isDefault() const
 516         {
 517             return mpViewInformation3D == ImpViewInformation3D::get_global_default();
 518         }
 519
 520         ViewInformation3D& ViewInformation3D::operator=(const ViewInformation3D& rCandidate)
 521         {
 522             ::osl::Mutex m_mutex;
 523
 524             if(mpViewInformation3D->mnRefCount)
 525             {
 526                 mpViewInformation3D->mnRefCount--;
 527             }
 528             else
 529             {
 530                 delete mpViewInformation3D;
 531             }
 532
 533             mpViewInformation3D = rCandidate.mpViewInformation3D;
 534             mpViewInformation3D->mnRefCount++;
 535
 536             return *this;
 537         }
 538
 539         bool ViewInformation3D::operator==(const ViewInformation3D& rCandidate) const
 540         {
 541             if(rCandidate.mpViewInformation3D == mpViewInformation3D)
 542             {
 543                 return true;
 544             }
 545
 546             if(rCandidate.isDefault() != isDefault())
 547             {
 548                 return false;
 549             }
 550
 551             return (*rCandidate.mpViewInformation3D == *mpViewInformation3D);
 552         }
 553
 554         const basegfx::B3DHomMatrix& ViewInformation3D::getObjectTransformation() const
 555         {
 556             return mpViewInformation3D->getObjectTransformation();
 557         }
 558
 559         const basegfx::B3DHomMatrix& ViewInformation3D::getOrientation() const
 560         {
 561             return mpViewInformation3D->getOrientation();
 562         }
 563
 564         const basegfx::B3DHomMatrix& ViewInformation3D::getProjection() const
 565         {
 566             return mpViewInformation3D->getProjection();
 567         }
 568
 569         const basegfx::B3DHomMatrix& ViewInformation3D::getDeviceToView() const
 570         {
 571             return mpViewInformation3D->getDeviceToView();
 572         }
 573
 574         const basegfx::B3DHomMatrix& ViewInformation3D::getObjectToView() const
 575         {
 576             return mpViewInformation3D->getObjectToView();
 577         }
 578
 579         double ViewInformation3D::getViewTime() const
 580         {
 581             return mpViewInformation3D->getViewTime();
 582         }
 583
 584         const uno::Sequence< beans::PropertyValue >& ViewInformation3D::getViewInformationSequence() const
 585         {
 586             return mpViewInformation3D->getViewInformationSequence();
 587         }
 588
 589         const uno::Sequence< beans::PropertyValue >& ViewInformation3D::getExtendedInformationSequence() const
 590         {
 591             return mpViewInformation3D->getExtendedInformationSequence();
 592         }
 593     } // end of namespace geometry
 594 } // end of namespace drawinglayer
 595
 596 //////////////////////////////////////////////////////////////////////////////
 597 // eof
 598
 599 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */