svx/source/sdr/contact/viewobjectcontactofsdrpage.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: viewobjectcontactofsdrpage.cxx,v $
  10  *
  11  * $Revision: 1.2 $
  12  *
  13  * This file is part of OpenOffice.org.
  14  *
  15  * OpenOffice.org is free software: you can redistribute it and/or modify
  16  * it under the terms of the GNU Lesser General Public License version 3
  17  * only, as published by the Free Software Foundation.
  18  *
  19  * OpenOffice.org is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU Lesser General Public License version 3 for more details
  23  * (a copy is included in the LICENSE file that accompanied this code).
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * version 3 along with OpenOffice.org.  If not, see
  27  * <http://www.openoffice.org/license.html>
  28  * for a copy of the LGPLv3 License.
  29  *
  30  ************************************************************************/
  31
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_svx.hxx"
  34
  35 #include <svx/sdr/contact/viewobjectcontactofsdrpage.hxx>
  36 #include <svx/sdr/contact/displayinfo.hxx>
  37 #include <svx/sdr/contact/viewcontactofsdrpage.hxx>
  38 #include <svx/svdview.hxx>
  39 #include <svx/svdpage.hxx>
  40 #include <svx/sdr/contact/objectcontact.hxx>
  41 #include <drawinglayer/primitive2d/backgroundcolorprimitive2d.hxx>
  42 #include <basegfx/polygon/b2dpolygontools.hxx>
  43 #include <drawinglayer/primitive2d/polypolygonprimitive2d.hxx>
  44 #include <drawinglayer/primitive2d/gridprimitive2d.hxx>
  45 #include <drawinglayer/primitive2d/helplineprimitive2d.hxx>
  46 #include <basegfx/polygon/b2dpolygon.hxx>
  47 #include <svx/sdr/primitive2d/sdrprimitivetools.hxx>
  48
  49 //////////////////////////////////////////////////////////////////////////////
  50
  51 using namespace com::sun::star;
  52
  53 //////////////////////////////////////////////////////////////////////////////
  54
  55 namespace sdr
  56 {
  57     namespace contact
  58     {
  59         const SdrPage& ViewObjectContactOfPageSubObject::getPage() const
  60         {
  61             return static_cast< ViewContactOfPageSubObject& >(GetViewContact()).getPage();
  62         }
  63
  64         ViewObjectContactOfPageSubObject::ViewObjectContactOfPageSubObject(ObjectContact& rObjectContact, ViewContact& rViewContact)
  65         :       ViewObjectContact(rObjectContact, rViewContact)
  66         {
  67         }
  68
  69         ViewObjectContactOfPageSubObject::~ViewObjectContactOfPageSubObject()
  70         {
  71         }
  72
  73         bool ViewObjectContactOfPageSubObject::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
  74         {
  75             if(rDisplayInfo.GetSubContentActive())
  76             {
  77                 return false;
  78             }
  79
  80             if(rDisplayInfo.GetControlLayerProcessingActive())
  81             {
  82                 return false;
  83             }
  84
  85             if(!rDisplayInfo.GetPageProcessingActive())
  86             {
  87                 return false;
  88             }
  89
  90             if(GetObjectContact().isOutputToPrinter())
  91             {
  92                 return false;
  93             }
  94
  95             if(!GetObjectContact().TryToGetSdrPageView())
  96             {
  97                 return false;
  98             }
  99
 100             return true;
 101         }
 102
 103         bool ViewObjectContactOfPageSubObject::isPrimitiveGhosted(const DisplayInfo& /*rDisplayInfo*/) const
 104         {
 105             // suppress ghosted for page parts
 106             return false;
 107         }
 108     } // end of namespace contact
 109 } // end of namespace sdr
 110
 111 //////////////////////////////////////////////////////////////////////////////
 112
 113 namespace sdr
 114 {
 115     namespace contact
 116     {
 117         ViewObjectContactOfPageBackground::ViewObjectContactOfPageBackground(ObjectContact& rObjectContact, ViewContact& rViewContact)
 118         :       ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
 119         {
 120         }
 121
 122         ViewObjectContactOfPageBackground::~ViewObjectContactOfPageBackground()
 123         {
 124         }
 125
 126         bool ViewObjectContactOfPageBackground::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
 127         {
 128             if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
 129             {
 130                 return false;
 131             }
 132
 133             // no page background for preview renderers
 134             if(GetObjectContact().IsPreviewRenderer())
 135             {
 136                 return false;
 137             }
 138
 139             return true;
 140         }
 141
 142         drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfPageBackground::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const
 143         {
 144             // Initialize background. Dependent of IsPageVisible, use ApplicationBackgroundColor or ApplicationDocumentColor. Most
 145             // old renderers for export (html, pdf, gallery, ...) set the page to not visible (SetPageVisible(false)). They expect the
 146             // given OutputDevice to be initialized with the ApplicationDocumentColor then.
 147             const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
 148             drawinglayer::primitive2d::Primitive2DSequence xRetval;
 149
 150             if(pPageView)
 151             {
 152                 const SdrView& rView = pPageView->GetView();
 153                 Color aInitColor;
 154
 155                 if(rView.IsPageVisible())
 156                 {
 157                     aInitColor = pPageView->GetApplicationBackgroundColor();
 158                 }
 159                 else
 160                 {
 161                     aInitColor = pPageView->GetApplicationDocumentColor();
 162
 163                     if(Color(COL_AUTO) == aInitColor)
 164                     {
 165                         const svtools::ColorConfig aColorConfig;
 166                         aInitColor = aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor;
 167                     }
 168                 }
 169
 170                 // init background with InitColor
 171                 xRetval.realloc(1);
 172                 const basegfx::BColor aRGBColor(aInitColor.getBColor());
 173                 xRetval[0] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::BackgroundColorPrimitive2D(aRGBColor));
 174             }
 175
 176             return xRetval;
 177         }
 178     } // end of namespace contact
 179 } // end of namespace sdr
 180
 181 //////////////////////////////////////////////////////////////////////////////
 182
 183 namespace sdr
 184 {
 185     namespace contact
 186     {
 187         ViewObjectContactOfMasterPage::ViewObjectContactOfMasterPage(ObjectContact& rObjectContact, ViewContact& rViewContact)
 188         :       ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
 189         {
 190         }
 191
 192         ViewObjectContactOfMasterPage::~ViewObjectContactOfMasterPage()
 193         {
 194         }
 195
 196         bool ViewObjectContactOfMasterPage::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
 197         {
 198             if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
 199             {
 200                 return false;
 201             }
 202
 203             // this object is only used for MasterPages. When not the MasterPage is
 204             // displayed as a page, but another page is using it as sub-object, the
 205             // geometry needs to be hidden
 206             if(rDisplayInfo.GetSubContentActive())
 207             {
 208                 return false;
 209             }
 210
 211             return true;
 212         }
 213     } // end of namespace contact
 214 } // end of namespace sdr
 215
 216 //////////////////////////////////////////////////////////////////////////////
 217
 218 namespace sdr
 219 {
 220     namespace contact
 221     {
 222         ViewObjectContactOfPageFill::ViewObjectContactOfPageFill(ObjectContact& rObjectContact, ViewContact& rViewContact)
 223         :       ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
 224         {
 225         }
 226
 227         ViewObjectContactOfPageFill::~ViewObjectContactOfPageFill()
 228         {
 229         }
 230
 231         bool ViewObjectContactOfPageFill::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
 232         {
 233             if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
 234             {
 235                 return false;
 236             }
 237
 238             SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 239
 240             if(!pSdrPageView)
 241             {
 242                 return false;
 243             }
 244
 245             if(!pSdrPageView->GetView().IsPageVisible())
 246             {
 247                 return false;
 248             }
 249
 250             return true;
 251         }
 252
 253         drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfPageFill::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const
 254         {
 255             const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
 256             drawinglayer::primitive2d::Primitive2DSequence xRetval;
 257
 258             if(pPageView)
 259             {
 260                 const SdrPage& rPage = getPage();
 261
 262                 const basegfx::B2DRange aPageFillRange(0.0, 0.0, (double)rPage.GetWdt(), (double)rPage.GetHgt());
 263                 const basegfx::B2DPolygon aPageFillPolygon(basegfx::tools::createPolygonFromRect(aPageFillRange));
 264                 Color aPageFillColor;
 265
 266                 if(pPageView->GetApplicationDocumentColor() != COL_AUTO)
 267                 {
 268                     aPageFillColor = pPageView->GetApplicationDocumentColor();
 269                 }
 270                 else
 271                 {
 272                     const svtools::ColorConfig aColorConfig;
 273                     aPageFillColor = aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor;
 274                 }
 275
 276                 // create and add primitive
 277                 xRetval.realloc(1);
 278                 const basegfx::BColor aRGBColor(aPageFillColor.getBColor());
 279                 xRetval[0] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aPageFillPolygon), aRGBColor));
 280             }
 281
 282             return xRetval;
 283         }
 284     } // end of namespace contact
 285 } // end of namespace sdr
 286
 287 //////////////////////////////////////////////////////////////////////////////
 288
 289 namespace sdr
 290 {
 291     namespace contact
 292     {
 293         ViewObjectContactOfPageShadow::ViewObjectContactOfPageShadow(ObjectContact& rObjectContact, ViewContact& rViewContact)
 294         :       ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
 295         {
 296         }
 297
 298         ViewObjectContactOfPageShadow::~ViewObjectContactOfPageShadow()
 299         {
 300         }
 301
 302         bool ViewObjectContactOfPageShadow::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
 303         {
 304             if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
 305             {
 306                 return false;
 307             }
 308
 309             SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 310
 311             if(!pSdrPageView)
 312             {
 313                 return false;
 314             }
 315
 316             if(!pSdrPageView->GetView().IsPageVisible())
 317             {
 318                 return false;
 319             }
 320
 321             // no page shadow for preview renderers
 322             if(GetObjectContact().IsPreviewRenderer())
 323             {
 324                 return false;
 325             }
 326
 327             return true;
 328         }
 329     } // end of namespace contact
 330 } // end of namespace sdr
 331
 332 //////////////////////////////////////////////////////////////////////////////
 333
 334 namespace sdr
 335 {
 336     namespace contact
 337     {
 338         ViewObjectContactOfOuterPageBorder::ViewObjectContactOfOuterPageBorder(ObjectContact& rObjectContact, ViewContact& rViewContact)
 339         :       ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
 340         {
 341         }
 342
 343         ViewObjectContactOfOuterPageBorder::~ViewObjectContactOfOuterPageBorder()
 344         {
 345         }
 346
 347         bool ViewObjectContactOfOuterPageBorder::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
 348         {
 349             if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
 350             {
 351                 return false;
 352             }
 353
 354             SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 355
 356             if(!pSdrPageView)
 357             {
 358                 return false;
 359             }
 360
 361             const SdrView& rView = pSdrPageView->GetView();
 362
 363             if(!rView.IsPageVisible() && rView.IsPageBorderVisible())
 364             {
 365                 return false;
 366             }
 367
 368             return true;
 369         }
 370     } // end of namespace contact
 371 } // end of namespace sdr
 372
 373 //////////////////////////////////////////////////////////////////////////////
 374
 375 namespace sdr
 376 {
 377     namespace contact
 378     {
 379         ViewObjectContactOfInnerPageBorder::ViewObjectContactOfInnerPageBorder(ObjectContact& rObjectContact, ViewContact& rViewContact)
 380         :       ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
 381         {
 382         }
 383
 384         ViewObjectContactOfInnerPageBorder::~ViewObjectContactOfInnerPageBorder()
 385         {
 386         }
 387
 388         bool ViewObjectContactOfInnerPageBorder::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
 389         {
 390             if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
 391             {
 392                 return false;
 393             }
 394
 395             SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 396
 397             if(!pSdrPageView)
 398             {
 399                 return false;
 400             }
 401
 402             if(!pSdrPageView->GetView().IsBordVisible())
 403             {
 404                 return false;
 405             }
 406
 407             const SdrPage& rPage = getPage();
 408
 409             if(!rPage.GetLftBorder() && !rPage.GetUppBorder() && !rPage.GetRgtBorder() && !rPage.GetLwrBorder())
 410             {
 411                 return false;
 412             }
 413
 414             // no inner page border for preview renderers
 415             if(GetObjectContact().IsPreviewRenderer())
 416             {
 417                 return false;
 418             }
 419
 420             return true;
 421         }
 422     } // end of namespace contact
 423 } // end of namespace sdr
 424
 425 //////////////////////////////////////////////////////////////////////////////
 426
 427 namespace sdr
 428 {
 429     namespace contact
 430     {
 431         ViewObjectContactOfPageHierarchy::ViewObjectContactOfPageHierarchy(ObjectContact& rObjectContact, ViewContact& rViewContact)
 432         :       ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
 433         {
 434         }
 435
 436         ViewObjectContactOfPageHierarchy::~ViewObjectContactOfPageHierarchy()
 437         {
 438         }
 439
 440         drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfPageHierarchy::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo) const
 441         {
 442             drawinglayer::primitive2d::Primitive2DSequence xRetval;
 443
 444             // process local sub-hierarchy
 445             const sal_uInt32 nSubHierarchyCount(GetViewContact().GetObjectCount());
 446
 447             if(nSubHierarchyCount)
 448             {
 449                 xRetval = getPrimitive2DSequenceSubHierarchy(rDisplayInfo);
 450
 451                 if(xRetval.hasElements())
 452                 {
 453                     // get ranges
 454                     const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D());
 455                     const basegfx::B2DRange aObjectRange(drawinglayer::primitive2d::getB2DRangeFromPrimitive2DSequence(xRetval, rViewInformation2D));
 456                     const basegfx::B2DRange aViewRange(rViewInformation2D.getViewport());
 457
 458                     // check geometrical visibility
 459                     if(!aViewRange.isEmpty() && !aViewRange.overlaps(aObjectRange))
 460                     {
 461                         // not visible, release
 462                         xRetval.realloc(0);
 463                     }
 464                 }
 465             }
 466
 467             return xRetval;
 468         }
 469     } // end of namespace contact
 470 } // end of namespace sdr
 471
 472 //////////////////////////////////////////////////////////////////////////////
 473
 474 namespace sdr
 475 {
 476     namespace contact
 477     {
 478         ViewObjectContactOfPageGrid::ViewObjectContactOfPageGrid(ObjectContact& rObjectContact, ViewContact& rViewContact)
 479         :       ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
 480         {
 481         }
 482
 483         ViewObjectContactOfPageGrid::~ViewObjectContactOfPageGrid()
 484         {
 485         }
 486
 487         bool ViewObjectContactOfPageGrid::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
 488         {
 489             if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
 490             {
 491                 return false;
 492             }
 493
 494             SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 495
 496             if(!pSdrPageView)
 497             {
 498                 return false;
 499             }
 500
 501             const SdrView& rView = pSdrPageView->GetView();
 502
 503             if(!rView.IsGridVisible())
 504             {
 505                 return false;
 506             }
 507
 508             // no page grid for preview renderers
 509             if(GetObjectContact().IsPreviewRenderer())
 510             {
 511                 return false;
 512             }
 513
 514             if(static_cast< ViewContactOfGrid& >(GetViewContact()).getFront() != (bool)rView.IsGridFront())
 515             {
 516                 return false;
 517             }
 518
 519             return true;
 520         }
 521
 522         drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfPageGrid::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const
 523         {
 524             const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
 525             drawinglayer::primitive2d::Primitive2DSequence xRetval;
 526
 527             if(pPageView)
 528             {
 529                 const SdrView& rView = pPageView->GetView();
 530                 const SdrPage& rPage = getPage();
 531                 const Color aGridColor(rView.GetGridColor());
 532                 const basegfx::BColor aRGBGridColor(aGridColor.getBColor());
 533
 534                 basegfx::B2DHomMatrix aGridMatrix;
 535                 aGridMatrix.set(0, 0, (double)(rPage.GetWdt() - (rPage.GetRgtBorder() + rPage.GetLftBorder())));
 536                 aGridMatrix.set(1, 1, (double)(rPage.GetHgt() - (rPage.GetLwrBorder() + rPage.GetUppBorder())));
 537                 aGridMatrix.set(0, 2, (double)rPage.GetLftBorder());
 538                 aGridMatrix.set(1, 2, (double)rPage.GetUppBorder());
 539
 540                 const Size aRaw(rView.GetGridCoarse());
 541                 const Size aFine(rView.GetGridFine());
 542                 const double fWidthX(aRaw.getWidth());
 543                 const double fWidthY(aRaw.getHeight());
 544                 const sal_uInt32 nSubdivisionsX(aFine.getWidth() ? aRaw.getWidth() / aFine.getWidth() : 0L);
 545                 const sal_uInt32 nSubdivisionsY(aFine.getHeight() ? aRaw.getHeight() / aFine.getHeight() : 0L);
 546
 547                 xRetval.realloc(1);
 548                 xRetval[0] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::GridPrimitive2D(
 549                     aGridMatrix, fWidthX, fWidthY, 10.0, 3.0, nSubdivisionsX, nSubdivisionsY, aRGBGridColor,
 550                     drawinglayer::primitive2d::createDefaultCross_3x3(aRGBGridColor)));
 551             }
 552
 553             return xRetval;
 554         }
 555     } // end of namespace contact
 556 } // end of namespace sdr
 557
 558 //////////////////////////////////////////////////////////////////////////////
 559
 560 namespace sdr
 561 {
 562     namespace contact
 563     {
 564         ViewObjectContactOfPageHelplines::ViewObjectContactOfPageHelplines(ObjectContact& rObjectContact, ViewContact& rViewContact)
 565         :       ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
 566         {
 567         }
 568
 569         ViewObjectContactOfPageHelplines::~ViewObjectContactOfPageHelplines()
 570         {
 571         }
 572
 573         bool ViewObjectContactOfPageHelplines::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
 574         {
 575             if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
 576             {
 577                 return false;
 578             }
 579
 580             SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 581
 582             if(!pSdrPageView)
 583             {
 584                 return false;
 585             }
 586
 587             const SdrView& rView = pSdrPageView->GetView();
 588
 589             if(!rView.IsHlplVisible())
 590             {
 591                 return false;
 592             }
 593
 594             // no helplines for preview renderers
 595             if(GetObjectContact().IsPreviewRenderer())
 596             {
 597                 return false;
 598             }
 599
 600             if(static_cast< ViewContactOfHelplines& >(GetViewContact()).getFront() != (bool)rView.IsHlplFront())
 601             {
 602                 return false;
 603             }
 604
 605             return true;
 606         }
 607
 608         drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfPageHelplines::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/) const
 609         {
 610             drawinglayer::primitive2d::Primitive2DSequence xRetval;
 611             const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
 612
 613             if(pPageView)
 614             {
 615                 const SdrHelpLineList& rHelpLineList = pPageView->GetHelpLines();
 616                 const sal_uInt32 nCount(rHelpLineList.GetCount());
 617
 618                 if(nCount)
 619                 {
 620                     const basegfx::BColor aRGBColorA(1.0, 1.0, 1.0);
 621                     const basegfx::BColor aRGBColorB(0.0, 0.0, 0.0);
 622                     xRetval.realloc(nCount);
 623
 624                     for(sal_uInt32 a(0L); a < nCount; a++)
 625                     {
 626                         const SdrHelpLine& rHelpLine = rHelpLineList[(sal_uInt16)a];
 627                         const basegfx::B2DPoint aPosition((double)rHelpLine.GetPos().X(), (double)rHelpLine.GetPos().Y());
 628                         const double fDiscreteDashLength(4.0);
 629
 630                         switch(rHelpLine.GetKind())
 631                         {
 632                             default : // SDRHELPLINE_POINT
 633                             {
 634                                 xRetval[a] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::HelplinePrimitive2D(
 635                                     aPosition, basegfx::B2DVector(1.0, 0.0), drawinglayer::primitive2d::HELPLINESTYLE2D_POINT,
 636                                     aRGBColorA, aRGBColorB, fDiscreteDashLength));
 637                                 break;
 638                             }
 639                             case SDRHELPLINE_VERTICAL :
 640                             {
 641                                 xRetval[a] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::HelplinePrimitive2D(
 642                                     aPosition, basegfx::B2DVector(0.0, 1.0), drawinglayer::primitive2d::HELPLINESTYLE2D_LINE,
 643                                     aRGBColorA, aRGBColorB, fDiscreteDashLength));
 644                                 break;
 645                             }
 646                             case SDRHELPLINE_HORIZONTAL :
 647                             {
 648                                 xRetval[a] = drawinglayer::primitive2d::Primitive2DReference(new drawinglayer::primitive2d::HelplinePrimitive2D(
 649                                     aPosition, basegfx::B2DVector(1.0, 0.0), drawinglayer::primitive2d::HELPLINESTYLE2D_LINE,
 650                                     aRGBColorA, aRGBColorB, fDiscreteDashLength));
 651                                 break;
 652                             }
 653                         }
 654                     }
 655                 }
 656             }
 657
 658             return xRetval;
 659         }
 660     } // end of namespace contact
 661 } // end of namespace sdr
 662
 663 //////////////////////////////////////////////////////////////////////////////
 664
 665 namespace sdr
 666 {
 667     namespace contact
 668     {
 669         ViewObjectContactOfSdrPage::ViewObjectContactOfSdrPage(ObjectContact& rObjectContact, ViewContact& rViewContact)
 670         :       ViewObjectContact(rObjectContact, rViewContact)
 671         {
 672         }
 673
 674         ViewObjectContactOfSdrPage::~ViewObjectContactOfSdrPage()
 675         {
 676         }
 677
 678         drawinglayer::primitive2d::Primitive2DSequence ViewObjectContactOfSdrPage::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo) const
 679         {
 680             drawinglayer::primitive2d::Primitive2DSequence xRetval;
 681
 682             // process local sub-hierarchy
 683             const sal_uInt32 nSubHierarchyCount(GetViewContact().GetObjectCount());
 684
 685             if(nSubHierarchyCount)
 686             {
 687                 const sal_Bool bDoGhostedDisplaying(
 688                     GetObjectContact().DoVisualizeEnteredGroup()
 689                     && !GetObjectContact().isOutputToPrinter()
 690                     && GetObjectContact().getActiveViewContact() == &GetViewContact());
 691
 692                 if(bDoGhostedDisplaying)
 693                 {
 694                     rDisplayInfo.ClearGhostedDrawMode();
 695                 }
 696
 697                 // create object hierarchy
 698                 xRetval = getPrimitive2DSequenceSubHierarchy(rDisplayInfo);
 699
 700                 if(xRetval.hasElements())
 701                 {
 702                     // get ranges
 703                     const drawinglayer::geometry::ViewInformation2D& rViewInformation2D(GetObjectContact().getViewInformation2D());
 704                     const basegfx::B2DRange aObjectRange(drawinglayer::primitive2d::getB2DRangeFromPrimitive2DSequence(xRetval, rViewInformation2D));
 705                     const basegfx::B2DRange aViewRange(rViewInformation2D.getViewport());
 706
 707                     // check geometrical visibility
 708                     if(!aViewRange.isEmpty() && !aViewRange.overlaps(aObjectRange))
 709                     {
 710                         // not visible, release
 711                         xRetval.realloc(0);
 712                     }
 713                 }
 714
 715                 if(bDoGhostedDisplaying)
 716                 {
 717                     rDisplayInfo.SetGhostedDrawMode();
 718                 }
 719             }
 720
 721             return xRetval;
 722         }
 723     } // end of namespace contact
 724 } // end of namespace sdr
 725
 726 //////////////////////////////////////////////////////////////////////////////
 727 // eof