drawinglayer/source/geometry/viewinformation2d.cxx

   1 /*************************************************************************
   2  *
   3  *  OpenOffice.org - a multi-platform office productivity suite
   4  *
   5  *  $RCSfile: viewinformation2d.cxx,v $
   6  *
   7  *  $Revision: 1.7 $
   8  *
   9  *  last change: $Author: aw $ $Date: 2008-06-24 15:31:07 $
  10  *
  11  *  The Contents of this file are made available subject to
  12  *  the terms of GNU Lesser General Public License Version 2.1.
  13  *
  14  *
  15  *    GNU Lesser General Public License Version 2.1
  16  *    =============================================
  17  *    Copyright 2005 by Sun Microsystems, Inc.
  18  *    901 San Antonio Road, Palo Alto, CA 94303, USA
  19  *
  20  *    This library is free software; you can redistribute it and/or
  21  *    modify it under the terms of the GNU Lesser General Public
  22  *    License version 2.1, as published by the Free Software Foundation.
  23  *
  24  *    This library is distributed in the hope that it will be useful,
  25  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  *    Lesser General Public License for more details.
  28  *
  29  *    You should have received a copy of the GNU Lesser General Public
  30  *    License along with this library; if not, write to the Free Software
  31  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  32  *    MA  02111-1307  USA
  33  *
  34  ************************************************************************/
  35
  36 // MARKER(update_precomp.py): autogen include statement, do not remove
  37 #include "precompiled_drawinglayer.hxx"
  38
  39 #include <drawinglayer/geometry/viewinformation2d.hxx>
  40 #include <basegfx/matrix/b2dhommatrix.hxx>
  41 #include <basegfx/range/b2drange.hxx>
  42 #include <osl/mutex.hxx>
  43 #include <basegfx/tools/canvastools.hxx>
  44 #include <com/sun/star/geometry/AffineMatrix2D.hpp>
  45 #include <com/sun/star/geometry/RealRectangle2D.hpp>
  46
  47 //////////////////////////////////////////////////////////////////////////////
  48
  49 using namespace com::sun::star;
  50
  51 //////////////////////////////////////////////////////////////////////////////
  52
  53 namespace drawinglayer
  54 {
  55     namespace geometry
  56     {
  57         class ImpViewInformation2D
  58         {
  59         private:
  60             // ViewInformation2D implementation can change refcount, so we have only
  61             // two memory regions for pairs of ViewInformation2D/ImpViewInformation2D
  62             friend class ::drawinglayer::geometry::ViewInformation2D;
  63
  64             // the refcounter. 0 means exclusively used
  65             sal_uInt32                                                                  mnRefCount;
  66
  67         protected:
  68             // the object transformation
  69             basegfx::B2DHomMatrix                                               maObjectTransformation;
  70
  71             // the view transformation
  72             basegfx::B2DHomMatrix                                               maViewTransformation;
  73
  74             // the ObjectToView and it's inverse, both on demand from ObjectTransformation
  75             // and ViewTransformation
  76             basegfx::B2DHomMatrix                                               maObjectToViewTransformation;
  77             basegfx::B2DHomMatrix                                               maInverseObjectToViewTransformation;
  78
  79             // the visible range and the on-demand one in ViewCoordinates
  80             basegfx::B2DRange                                                   maViewport;
  81             basegfx::B2DRange                                                   maDiscreteViewport;
  82
  83             // the DrawPage which is target of visualisation. This is needed e.g. for
  84             // the view-dependent decomposition of PageNumber TextFields
  85             uno::Reference< drawing::XDrawPage >                mxVisualizedPage;
  86
  87             // the point in time
  88             double                                                                              mfViewTime;
  89
  90             // the complete PropertyValue representation (if already created)
  91             uno::Sequence< beans::PropertyValue >               mxViewInformation;
  92
  93             // the extra PropertyValues; not represented by ViewTransformation,
  94             // Viewport, VisualizedPage or ViewTime
  95             uno::Sequence< beans::PropertyValue >               mxExtendedInformation;
  96
  97             // the local UNO API strings
  98             const ::rtl::OUString& getNamePropertyObjectTransformation()
  99             {
 100                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("ObjectTransformation"));
 101                 return s_sNameProperty;
 102             }
 103
 104             const ::rtl::OUString& getNamePropertyViewTransformation()
 105             {
 106                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("ViewTransformation"));
 107                 return s_sNameProperty;
 108             }
 109
 110             const ::rtl::OUString& getNamePropertyViewport()
 111             {
 112                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Viewport"));
 113                 return s_sNameProperty;
 114             }
 115
 116             const ::rtl::OUString& getNamePropertyTime()
 117             {
 118                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("Time"));
 119                 return s_sNameProperty;
 120             }
 121
 122             const ::rtl::OUString& getNamePropertyVisualizedPage()
 123             {
 124                 static ::rtl::OUString s_sNameProperty(RTL_CONSTASCII_USTRINGPARAM("VisualizedPage"));
 125                 return s_sNameProperty;
 126             }
 127
 128             void impInterpretPropertyValues(const uno::Sequence< beans::PropertyValue >& rViewParameters)
 129             {
 130                 if(rViewParameters.hasElements())
 131                 {
 132                     const sal_Int32 nCount(rViewParameters.getLength());
 133                     sal_Int32 nExtendedInsert(0);
 134
 135                     // prepare extended information for filtering. Maximum size is nCount
 136                     mxExtendedInformation.realloc(nCount);
 137
 138                     for(sal_Int32 a(0); a < nCount; a++)
 139                     {
 140                         const beans::PropertyValue& rProp = rViewParameters[a];
 141
 142                         if(rProp.Name == getNamePropertyObjectTransformation())
 143                         {
 144                             com::sun::star::geometry::AffineMatrix2D aAffineMatrix2D;
 145                             rProp.Value >>= aAffineMatrix2D;
 146                             basegfx::unotools::homMatrixFromAffineMatrix(maObjectTransformation, aAffineMatrix2D);
 147                         }
 148                         else if(rProp.Name == getNamePropertyViewTransformation())
 149                         {
 150                             com::sun::star::geometry::AffineMatrix2D aAffineMatrix2D;
 151                             rProp.Value >>= aAffineMatrix2D;
 152                             basegfx::unotools::homMatrixFromAffineMatrix(maViewTransformation, aAffineMatrix2D);
 153                         }
 154                         else if(rProp.Name == getNamePropertyViewport())
 155                         {
 156                             com::sun::star::geometry::RealRectangle2D aViewport;
 157                             rProp.Value >>= aViewport;
 158                             maViewport = basegfx::unotools::b2DRectangleFromRealRectangle2D(aViewport);
 159                         }
 160                         else if(rProp.Name == getNamePropertyTime())
 161                         {
 162                             rProp.Value >>= mfViewTime;
 163                         }
 164                         else if(rProp.Name == getNamePropertyVisualizedPage())
 165                         {
 166                             rProp.Value >>= mxVisualizedPage;
 167                         }
 168                         else
 169                         {
 170                             // extra information; add to filtered information
 171                             mxExtendedInformation[nExtendedInsert++] = rProp;
 172                         }
 173                     }
 174
 175                     // extra information size is now known; realloc to final size
 176                     mxExtendedInformation.realloc(nExtendedInsert);
 177                 }
 178             }
 179
 180             void impFillViewInformationFromContent()
 181             {
 182                 uno::Sequence< beans::PropertyValue > xRetval;
 183                 const bool bObjectTransformationUsed(!maObjectTransformation.isIdentity());
 184                 const bool bViewTransformationUsed(!maViewTransformation.isIdentity());
 185                 const bool bViewportUsed(!maViewport.isEmpty());
 186                 const bool bTimeUsed(0.0 < mfViewTime);
 187                 const bool bVisualizedPageUsed(mxVisualizedPage.is());
 188                 const bool bExtraInformation(mxExtendedInformation.hasElements());
 189                 sal_uInt32 nIndex(0);
 190                 const sal_uInt32 nCount(
 191                     (bObjectTransformationUsed ? 1 : 0) +
 192                     (bViewTransformationUsed ? 1 : 0) +
 193                     (bViewportUsed ? 1 : 0) +
 194                     (bTimeUsed ? 1 : 0) +
 195                     (bVisualizedPageUsed ? 1 : 0) +
 196                     (bExtraInformation ? mxExtendedInformation.getLength() : 0));
 197
 198                 mxViewInformation.realloc(nCount);
 199
 200                 if(bObjectTransformationUsed)
 201                 {
 202                     com::sun::star::geometry::AffineMatrix2D aAffineMatrix2D;
 203                     basegfx::unotools::affineMatrixFromHomMatrix(aAffineMatrix2D, maObjectTransformation);
 204                     mxViewInformation[nIndex].Name = getNamePropertyObjectTransformation();
 205                     mxViewInformation[nIndex].Value <<= aAffineMatrix2D;
 206                     nIndex++;
 207                 }
 208
 209                 if(bViewTransformationUsed)
 210                 {
 211                     com::sun::star::geometry::AffineMatrix2D aAffineMatrix2D;
 212                     basegfx::unotools::affineMatrixFromHomMatrix(aAffineMatrix2D, maViewTransformation);
 213                     mxViewInformation[nIndex].Name = getNamePropertyViewTransformation();
 214                     mxViewInformation[nIndex].Value <<= aAffineMatrix2D;
 215                     nIndex++;
 216                 }
 217
 218                 if(bViewportUsed)
 219                 {
 220                     const com::sun::star::geometry::RealRectangle2D aViewport(basegfx::unotools::rectangle2DFromB2DRectangle(maViewport));
 221                     mxViewInformation[nIndex].Name = getNamePropertyViewport();
 222                     mxViewInformation[nIndex].Value <<= aViewport;
 223                     nIndex++;
 224                 }
 225
 226                 if(bTimeUsed)
 227                 {
 228                     mxViewInformation[nIndex].Name = getNamePropertyTime();
 229                     mxViewInformation[nIndex].Value <<= mfViewTime;
 230                     nIndex++;
 231                 }
 232
 233                 if(bVisualizedPageUsed)
 234                 {
 235                     mxViewInformation[nIndex].Name = getNamePropertyVisualizedPage();
 236                     mxViewInformation[nIndex].Value <<= mxVisualizedPage;
 237                     nIndex++;
 238                 }
 239
 240                 if(bExtraInformation)
 241                 {
 242                     const sal_Int32 nExtra(mxExtendedInformation.getLength());
 243
 244                     for(sal_Int32 a(0); a < nExtra; a++)
 245                     {
 246                         mxViewInformation[nIndex++] = mxExtendedInformation[a];
 247                     }
 248                 }
 249             }
 250
 251         public:
 252             ImpViewInformation2D(
 253                 const basegfx::B2DHomMatrix& rObjectTransformation,
 254                 const basegfx::B2DHomMatrix& rViewTransformation,
 255                 const basegfx::B2DRange& rViewport,
 256                 const uno::Reference< drawing::XDrawPage >& rxDrawPage,
 257                 double fViewTime,
 258                 const uno::Sequence< beans::PropertyValue >& rExtendedParameters)
 259             :   mnRefCount(0),
 260                 maObjectTransformation(rObjectTransformation),
 261                 maViewTransformation(rViewTransformation),
 262                 maObjectToViewTransformation(),
 263                 maInverseObjectToViewTransformation(),
 264                 maViewport(rViewport),
 265                 maDiscreteViewport(),
 266                 mxVisualizedPage(rxDrawPage),
 267                 mfViewTime(fViewTime),
 268                 mxViewInformation(),
 269                 mxExtendedInformation()
 270             {
 271                 impInterpretPropertyValues(rExtendedParameters);
 272             }
 273
 274             ImpViewInformation2D(const uno::Sequence< beans::PropertyValue >& rViewParameters)
 275             :   mnRefCount(0),
 276                 maObjectTransformation(),
 277                 maViewTransformation(),
 278                 maObjectToViewTransformation(),
 279                 maInverseObjectToViewTransformation(),
 280                 maViewport(),
 281                 maDiscreteViewport(),
 282                 mxVisualizedPage(),
 283                 mfViewTime(),
 284                 mxViewInformation(rViewParameters),
 285                 mxExtendedInformation()
 286             {
 287                 impInterpretPropertyValues(rViewParameters);
 288             }
 289
 290             const basegfx::B2DHomMatrix& getObjectTransformation() const
 291             {
 292                 return maObjectTransformation;
 293             }
 294
 295             const basegfx::B2DHomMatrix& getViewTransformation() const
 296             {
 297                 return maViewTransformation;
 298             }
 299
 300             const basegfx::B2DRange& getViewport() const
 301             {
 302                 return maViewport;
 303             }
 304
 305             const basegfx::B2DRange& getDiscreteViewport() const
 306             {
 307                 ::osl::Mutex m_mutex;
 308
 309                 if(maDiscreteViewport.isEmpty() && !maViewport.isEmpty())
 310                 {
 311                     basegfx::B2DRange aDiscreteViewport(maViewport);
 312                     aDiscreteViewport.transform(getViewTransformation());
 313                     const_cast< ImpViewInformation2D* >(this)->maDiscreteViewport = aDiscreteViewport;
 314                 }
 315
 316                 return maDiscreteViewport;
 317             }
 318
 319             const basegfx::B2DHomMatrix& getObjectToViewTransformation() const
 320             {
 321                 ::osl::Mutex m_mutex;
 322
 323                 if(maObjectToViewTransformation.isIdentity() &&
 324                     (!maObjectTransformation.isIdentity() || !maViewTransformation.isIdentity()))
 325                 {
 326                     basegfx::B2DHomMatrix aObjectToView(maViewTransformation * maObjectTransformation);
 327                     const_cast< ImpViewInformation2D* >(this)->maObjectToViewTransformation = aObjectToView;
 328                 }
 329
 330                 return maObjectToViewTransformation;
 331             }
 332
 333             const basegfx::B2DHomMatrix& getInverseObjectToViewTransformation() const
 334             {
 335                 ::osl::Mutex m_mutex;
 336
 337                 if(maInverseObjectToViewTransformation.isIdentity() &&
 338                     (!maObjectTransformation.isIdentity() || !maViewTransformation.isIdentity()))
 339                 {
 340                     basegfx::B2DHomMatrix aInverseObjectToView(maViewTransformation * maObjectTransformation);
 341                     aInverseObjectToView.invert();
 342                     const_cast< ImpViewInformation2D* >(this)->maInverseObjectToViewTransformation = aInverseObjectToView;
 343                 }
 344
 345                 return maInverseObjectToViewTransformation;
 346             }
 347
 348             double getViewTime() const
 349             {
 350                 return mfViewTime;
 351             }
 352
 353             const uno::Reference< drawing::XDrawPage >& getVisualizedPage() const
 354             {
 355                 return mxVisualizedPage;
 356             }
 357
 358             const uno::Sequence< beans::PropertyValue >& getViewInformationSequence() const
 359             {
 360                 if(!mxViewInformation.hasElements())
 361                 {
 362                     const_cast< ImpViewInformation2D* >(this)->impFillViewInformationFromContent();
 363                 }
 364
 365                 return mxViewInformation;
 366             }
 367
 368             const uno::Sequence< beans::PropertyValue >& getExtendedInformationSequence() const
 369             {
 370                 return mxExtendedInformation;
 371             }
 372
 373             bool operator==(const ImpViewInformation2D& rCandidate) const
 374             {
 375                 return (maObjectTransformation == rCandidate.maObjectTransformation
 376                     && maViewTransformation == rCandidate.maViewTransformation
 377                     && maViewport == rCandidate.maViewport
 378                     && mxVisualizedPage == rCandidate.mxVisualizedPage
 379                     && mfViewTime == rCandidate.mfViewTime
 380                     && mxExtendedInformation == rCandidate.mxExtendedInformation);
 381             }
 382         };
 383     } // end of anonymous namespace
 384 } // end of namespace drawinglayer
 385
 386 //////////////////////////////////////////////////////////////////////////////
 387
 388 namespace drawinglayer
 389 {
 390     namespace geometry
 391     {
 392         ViewInformation2D::ViewInformation2D(
 393             const basegfx::B2DHomMatrix& rObjectTransformation,
 394             const basegfx::B2DHomMatrix& rViewTransformation,
 395             const basegfx::B2DRange& rViewport,
 396             const uno::Reference< drawing::XDrawPage >& rxDrawPage,
 397             double fViewTime,
 398             const uno::Sequence< beans::PropertyValue >& rExtendedParameters)
 399         :       mpViewInformation2D(new ImpViewInformation2D(
 400                 rObjectTransformation,
 401                 rViewTransformation,
 402                 rViewport,
 403                 rxDrawPage,
 404                 fViewTime,
 405                 rExtendedParameters))
 406         {
 407         }
 408
 409         ViewInformation2D::ViewInformation2D(const uno::Sequence< beans::PropertyValue >& rViewParameters)
 410         :       mpViewInformation2D(new ImpViewInformation2D(rViewParameters))
 411         {
 412         }
 413
 414         ViewInformation2D::ViewInformation2D(const ViewInformation2D& rCandidate)
 415         :       mpViewInformation2D(rCandidate.mpViewInformation2D)
 416         {
 417             ::osl::Mutex m_mutex;
 418             mpViewInformation2D->mnRefCount++;
 419         }
 420
 421         ViewInformation2D::~ViewInformation2D()
 422         {
 423             ::osl::Mutex m_mutex;
 424
 425             if(mpViewInformation2D->mnRefCount)
 426             {
 427                 mpViewInformation2D->mnRefCount--;
 428             }
 429             else
 430             {
 431                 delete mpViewInformation2D;
 432             }
 433         }
 434
 435         ViewInformation2D& ViewInformation2D::operator=(const ViewInformation2D& rCandidate)
 436         {
 437             ::osl::Mutex m_mutex;
 438
 439             if(mpViewInformation2D->mnRefCount)
 440             {
 441                 mpViewInformation2D->mnRefCount--;
 442             }
 443             else
 444             {
 445                 delete mpViewInformation2D;
 446             }
 447
 448             mpViewInformation2D = rCandidate.mpViewInformation2D;
 449             mpViewInformation2D->mnRefCount++;
 450
 451             return *this;
 452         }
 453
 454         bool ViewInformation2D::operator==(const ViewInformation2D& rCandidate) const
 455         {
 456             if(rCandidate.mpViewInformation2D == mpViewInformation2D)
 457             {
 458                 return true;
 459             }
 460
 461             return (*rCandidate.mpViewInformation2D == *mpViewInformation2D);
 462         }
 463
 464         const basegfx::B2DHomMatrix& ViewInformation2D::getObjectTransformation() const
 465         {
 466             return mpViewInformation2D->getObjectTransformation();
 467         }
 468
 469         const basegfx::B2DHomMatrix& ViewInformation2D::getViewTransformation() const
 470         {
 471             return mpViewInformation2D->getViewTransformation();
 472         }
 473
 474         const basegfx::B2DRange& ViewInformation2D::getViewport() const
 475         {
 476             return mpViewInformation2D->getViewport();
 477         }
 478
 479         double ViewInformation2D::getViewTime() const
 480         {
 481             return mpViewInformation2D->getViewTime();
 482         }
 483
 484         const uno::Reference< drawing::XDrawPage >& ViewInformation2D::getVisualizedPage() const
 485         {
 486             return mpViewInformation2D->getVisualizedPage();
 487         }
 488
 489         const basegfx::B2DHomMatrix& ViewInformation2D::getObjectToViewTransformation() const
 490         {
 491             return mpViewInformation2D->getObjectToViewTransformation();
 492         }
 493
 494         const basegfx::B2DHomMatrix& ViewInformation2D::getInverseObjectToViewTransformation() const
 495         {
 496             return mpViewInformation2D->getInverseObjectToViewTransformation();
 497         }
 498
 499         const basegfx::B2DRange& ViewInformation2D::getDiscreteViewport() const
 500         {
 501             return mpViewInformation2D->getDiscreteViewport();
 502         }
 503
 504         const uno::Sequence< beans::PropertyValue >& ViewInformation2D::getViewInformationSequence() const
 505         {
 506             return mpViewInformation2D->getViewInformationSequence();
 507         }
 508
 509         const uno::Sequence< beans::PropertyValue >& ViewInformation2D::getExtendedInformationSequence() const
 510         {
 511             return mpViewInformation2D->getExtendedInformationSequence();
 512         }
 513     } // end of namespace geometry
 514 } // end of namespace drawinglayer
 515
 516 //////////////////////////////////////////////////////////////////////////////
 517 // eof