svx/source/sdr/contact/objectcontactofpageview.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <config_feature_desktop.h>
  21
  22 #include <svx/sdr/contact/objectcontactofpageview.hxx>
  23 #include <sdr/contact/viewobjectcontactofunocontrol.hxx>
  24 #include <svx/svdpagv.hxx>
  25 #include <svx/svdpage.hxx>
  26 #include <svx/sdr/contact/displayinfo.hxx>
  27 #include <svx/sdr/contact/viewobjectcontact.hxx>
  28 #include <svx/svdview.hxx>
  29 #include <svx/sdr/contact/viewcontact.hxx>
  30 #include <svx/sdr/animation/objectanimator.hxx>
  31 #include <svx/sdrpagewindow.hxx>
  32 #include <svx/sdrpaintwindow.hxx>
  33 #include <svtools/colorcfg.hxx>
  34 #include <sfx2/viewsh.hxx>
  35 #include <basegfx/matrix/b2dhommatrix.hxx>
  36 #include <drawinglayer/processor2d/baseprocessor2d.hxx>
  37 #include <drawinglayer/processor2d/processor2dtools.hxx>
  38 #include <osl/diagnose.h>
  39 #include <officecfg/Office/Common.hxx>
  40 #include <svx/unoapi.hxx>
  41 #include <comphelper/configuration.hxx>
  42 #include <vcl/canvastools.hxx>
  43 #include <vcl/pdfextoutdevdata.hxx>
  44 #include <comphelper/lok.hxx>
  45
  46 #include <memory>
  47
  48 using namespace com::sun::star;
  49
  50 namespace sdr::contact
  51 {
  52         // internal access to SdrPage of SdrPageView
  53         SdrPage* ObjectContactOfPageView::GetSdrPage() const
  54         {
  55             return GetPageWindow().GetPageView().GetPage();
  56         }
  57
  58         ObjectContactOfPageView::ObjectContactOfPageView(
  59                 SdrPageWindow& rPageWindow, const char *pDebugName)
  60             : Idle(pDebugName)
  61             , mrPageWindow(rPageWindow)
  62         {
  63             // init PreviewRenderer flag
  64             setPreviewRenderer(static_cast<SdrPaintView&>(rPageWindow.GetPageView().GetView()).IsPreviewRenderer());
  65
  66             // init timer
  67             SetPriority(TaskPriority::HIGH_IDLE);
  68             Stop();
  69         }
  70
  71         ObjectContactOfPageView::~ObjectContactOfPageView()
  72         {
  73             // stop timer
  74             Stop();
  75         }
  76
  77         // LazyInvalidate request. Take action.
  78         void ObjectContactOfPageView::setLazyInvalidate(ViewObjectContact& /*rVOC*/)
  79         {
  80             // do NOT call parent, but remember that something is to do by
  81             // starting the LazyInvalidateTimer
  82             Start();
  83         }
  84
  85         // call this to support evtl. preparations for repaint
  86         void ObjectContactOfPageView::PrepareProcessDisplay()
  87         {
  88             if(IsActive())
  89                 // there are still non-triggered LazyInvalidate events, trigger these
  90                 Invoke();
  91         }
  92
  93         // From baseclass Timer, the timeout call triggered by the LazyInvalidate mechanism
  94         void ObjectContactOfPageView::Invoke()
  95         {
  96             // stop the timer
  97             Stop();
  98
  99             // invalidate all LazyInvalidate VOCs new situations
 100             const sal_uInt32 nVOCCount(getViewObjectContactCount());
 101
 102             for(sal_uInt32 a(0); a < nVOCCount; a++)
 103             {
 104                 ViewObjectContact* pCandidate = getViewObjectContact(a);
 105                 pCandidate->triggerLazyInvalidate();
 106             }
 107         }
 108
 109         // Process the whole displaying
 110         void ObjectContactOfPageView::ProcessDisplay(DisplayInfo& rDisplayInfo)
 111         {
 112             const SdrPage* pStartPage = GetSdrPage();
 113
 114             if(pStartPage && !rDisplayInfo.GetProcessLayers().IsEmpty())
 115             {
 116                 const ViewContact& rDrawPageVC = pStartPage->GetViewContact();
 117
 118                 if(rDrawPageVC.GetObjectCount())
 119                 {
 120                     DoProcessDisplay(rDisplayInfo);
 121                 }
 122             }
 123         }
 124
 125         // Process the whole displaying. Only use given DisplayInfo, do not access other
 126         // OutputDevices then the given ones.
 127         void ObjectContactOfPageView::DoProcessDisplay(DisplayInfo& rDisplayInfo)
 128         {
 129             OutputDevice& rTargetOutDev = GetPageWindow().GetPaintWindow().GetTargetOutputDevice();
 130             const Size aOutputSizePixel(rTargetOutDev.GetOutputSizePixel());
 131             if (!isOutputToRecordingMetaFile() // do those have outdev too?
 132                 && (0 == aOutputSizePixel.getWidth() ||
 133                     0 == aOutputSizePixel.getHeight()))
 134             {
 135                 return;
 136             }
 137
 138             // visualize entered group when that feature is switched on and it's not
 139             // a print output. #i29129# No ghosted display for printing.
 140             bool bVisualizeEnteredGroup(DoVisualizeEnteredGroup() && !isOutputToPrinter());
 141
 142             // Visualize entered groups: Set to ghosted as default
 143             // start. Do this only for the DrawPage, not for MasterPages
 144             if(bVisualizeEnteredGroup)
 145             {
 146                 rDisplayInfo.SetGhostedDrawMode();
 147             }
 148
 149             // #114359# save old and set clip region
 150             OutputDevice* pOutDev = TryToGetOutputDevice();
 151             OSL_ENSURE(nullptr != pOutDev, "ObjectContactOfPageView without OutDev, someone has overridden TryToGetOutputDevice wrong (!)");
 152             bool bClipRegionPushed(false);
 153             const vcl::Region& rRedrawArea(rDisplayInfo.GetRedrawArea());
 154
 155             // tdf#153102 using the given RedrawArea is needed e.g. for Writer's
 156             // visual clipping against PageBounds (also for android viewer)
 157             if(!rRedrawArea.IsEmpty())
 158             {
 159                 bClipRegionPushed = true;
 160                 pOutDev->Push(vcl::PushFlags::CLIPREGION);
 161                 pOutDev->IntersectClipRegion(rRedrawArea);
 162             }
 163
 164             // Get start node and process DrawPage contents
 165             const ViewObjectContact& rDrawPageVOContact = GetSdrPage()->GetViewContact().GetViewObjectContact(*this);
 166
 167             // update current ViewInformation2D at the ObjectContact
 168             const double fCurrentTime(getPrimitiveAnimator().GetTime());
 169             basegfx::B2DRange aViewRange;
 170
 171             // create ViewRange
 172             if(isOutputToRecordingMetaFile())
 173             {
 174                 if (!rDisplayInfo.GetRedrawArea().IsEmpty())
 175                 {
 176                     // #i98402# if it's a PDF export, set the ClipRegion as ViewRange. This is
 177                     // mainly because SW does not use DrawingLayer Page-Oriented and if not doing this,
 178                     // all existing objects will be collected as primitives and processed.
 179                     // OD 2009-03-05 #i99876# perform the same also for SW on printing.
 180                     // fdo#78149 same thing also needed for plain MetaFile
 181                     //           export, so why not do it always
 182                     const tools::Rectangle aLogicClipRectangle(rDisplayInfo.GetRedrawArea().GetBoundRect());
 183
 184                     aViewRange = vcl::unotools::b2DRectangleFromRectangle(aLogicClipRectangle);
 185                 }
 186             }
 187             else
 188             {
 189                 // use visible pixels, but transform to world coordinates
 190                 aViewRange = basegfx::B2DRange(0.0, 0.0, aOutputSizePixel.getWidth(), aOutputSizePixel.getHeight());
 191                 // if a clip region is set, use it
 192                 if(!rDisplayInfo.GetRedrawArea().IsEmpty())
 193                 {
 194                     // get logic clip range and create discrete one
 195                     const tools::Rectangle aLogicClipRectangle(rDisplayInfo.GetRedrawArea().GetBoundRect());
 196                     basegfx::B2DRange aDiscreteClipRange = vcl::unotools::b2DRectangleFromRectangle(aLogicClipRectangle);
 197                     aDiscreteClipRange.transform(rTargetOutDev.GetViewTransformation());
 198
 199                     // align the discrete one to discrete boundaries (pixel bounds). Also
 200                     // expand X and Y max by one due to Rectangle definition source
 201                     aDiscreteClipRange.expand(basegfx::B2DTuple(
 202                         floor(aDiscreteClipRange.getMinX()),
 203                         floor(aDiscreteClipRange.getMinY())));
 204                     aDiscreteClipRange.expand(basegfx::B2DTuple(
 205                         1.0 + ceil(aDiscreteClipRange.getMaxX()),
 206                         1.0 + ceil(aDiscreteClipRange.getMaxY())));
 207
 208                     // intersect current ViewRange with ClipRange
 209                     aViewRange.intersect(aDiscreteClipRange);
 210                 }
 211
 212                 // transform to world coordinates
 213                 aViewRange.transform(rTargetOutDev.GetInverseViewTransformation());
 214             }
 215
 216             // update local ViewInformation2D
 217             drawinglayer::geometry::ViewInformation2D aNewViewInformation2D;
 218             aNewViewInformation2D.setViewTransformation(rTargetOutDev.GetViewTransformation());
 219             aNewViewInformation2D.setViewport(aViewRange);
 220             aNewViewInformation2D.setVisualizedPage(GetXDrawPageForSdrPage(GetSdrPage()));
 221             aNewViewInformation2D.setViewTime(fCurrentTime);
 222             if (const SfxViewShell* pViewShell = SfxViewShell::Current())
 223                 aNewViewInformation2D.setAutoColor(pViewShell->GetColorConfigColor(svtools::DOCCOLOR));
 224             if (static_cast<SdrPaintView&>(mrPageWindow.GetPageView().GetView()).IsTextEdit())
 225                 aNewViewInformation2D.setTextEditActive(true);
 226
 227             // this is the EditView repaint, provide that information,
 228             // but only if we do not export to metafile
 229             if (!isOutputToRecordingMetaFile())
 230                 aNewViewInformation2D.setEditViewActive(true);
 231
 232             updateViewInformation2D(aNewViewInformation2D);
 233
 234             drawinglayer::primitive2d::Primitive2DContainer xPrimitiveSequence;
 235
 236 #if HAVE_FEATURE_DESKTOP || defined( ANDROID )
 237             // get whole Primitive2DContainer; this will already make use of updated ViewInformation2D
 238             // and may use the MapMode from the Target OutDev in the DisplayInfo
 239             rDrawPageVOContact.getPrimitive2DSequenceHierarchy(rDisplayInfo, xPrimitiveSequence);
 240 #else
 241             // Hmm, !HAVE_FEATURE_DESKTOP && !ANDROID means iOS,
 242             // right? But does it makes sense to use a different code
 243             // path for iOS than for Android; both use tiled rendering
 244             // etc now.
 245
 246             // HACK: this only works when we are drawing sdr shapes via
 247             // drawinglayer; but it can happen that the hierarchy contains
 248             // more than just the shapes, and then it fails.
 249             //
 250             // This is good enough for the tiled rendering for the moment, but
 251             // we need to come up with the real solution shortly.
 252
 253             // Only get the expensive hierarchy if we can be sure that the
 254             // returned sequence won't be empty anyway.
 255             bool bGetHierarchy = rRedrawArea.IsEmpty();
 256             if (!bGetHierarchy)
 257             {
 258                 // Not empty? Then not doing a full redraw, check if
 259                 // getPrimitive2DSequenceHierarchy() is still needed.
 260                 for (const rtl::Reference<SdrObject>& pObject : *GetSdrPage())
 261                 {
 262                     if (rRedrawArea.Overlaps(pObject->GetCurrentBoundRect()))
 263                     {
 264                         bGetHierarchy = true;
 265                         break;
 266                     }
 267                 }
 268             }
 269
 270             if (bGetHierarchy)
 271                 // get whole Primitive2DContainer; this will already make use of updated ViewInformation2D
 272                 // and may use the MapMode from the Target OutDev in the DisplayInfo
 273                 rDrawPageVOContact.getPrimitive2DSequenceHierarchy(rDisplayInfo, xPrimitiveSequence);
 274 #endif
 275
 276             // if there is something to show, use a primitive processor to render it. There
 277             // is a choice between VCL and Canvas processors currently. The decision is made in
 278             // createProcessor2DFromOutputDevice and takes into account things like the
 279             // Target is a MetaFile, a VDev or something else. The Canvas renderer is triggered
 280             // currently using the shown boolean. Canvas is not yet the default.
 281             if(!xPrimitiveSequence.empty())
 282             {
 283                 // prepare OutputDevice (historical stuff, maybe soon removed)
 284                 rDisplayInfo.ClearGhostedDrawMode(); // reset, else the VCL-paint with the processor will not do the right thing
 285                 pOutDev->SetLayoutMode(vcl::text::ComplexTextLayoutFlags::Default); // reset, default is no BiDi/RTL
 286                 // create renderer
 287                 std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor2D(
 288                     drawinglayer::processor2d::createProcessor2DFromOutputDevice(
 289                         rTargetOutDev, getViewInformation2D()));
 290                 pProcessor2D->process(xPrimitiveSequence);
 291             }
 292
 293             // #114359# restore old ClipReghion
 294             if(bClipRegionPushed)
 295             {
 296                 pOutDev->Pop();
 297             }
 298
 299             // Visualize entered groups: Reset to original DrawMode
 300             if(bVisualizeEnteredGroup)
 301             {
 302                 rDisplayInfo.ClearGhostedDrawMode();
 303             }
 304         }
 305
 306         // test if visualizing of entered groups is switched on at all
 307         bool ObjectContactOfPageView::DoVisualizeEnteredGroup() const
 308         {
 309             return true;
 310         }
 311
 312         // get active group's (the entered group) ViewContact
 313         const ViewContact* ObjectContactOfPageView::getActiveViewContact() const
 314         {
 315             SdrObjList* pActiveGroupList = GetPageWindow().GetPageView().GetObjList();
 316
 317             if(pActiveGroupList)
 318             {
 319                 // tdf#122735
 320                 // Here it is necessary to check for SdrObject 1st, that may
 321                 // return nullptr if it is not a SdrObject/SdrObjGroup.
 322                 // Checking for SrPage OTOH will *always* try to return
 323                 // something useful due to SdrObjGroup::getSdrPageFromSdrObjList
 324                 // using getSdrPageFromSdrObject which will recursively go up the
 325                 // hierarchy to get the SdrPage the SdrObject belongs to, so
 326                 // this will *not* be nullptr for e.g. a SdrObjGroup if the
 327                 // SdrObjGroup is inserted to a SdrPage.
 328                 // NOTE: It is also possible to use dynamic_cast<SdrObjGroup*>
 329                 //       here, but getSdrObjectFromSdrObjList and
 330                 //       getSdrPageFromSdrObjListexist  to not need to do that
 331                 SdrObject* pSdrObject(pActiveGroupList->getSdrObjectFromSdrObjList());
 332
 333                 if(nullptr != pSdrObject)
 334                 {
 335                     // It is a group object
 336                     return &(pSdrObject->GetViewContact());
 337                 }
 338                 else
 339                 {
 340                     SdrPage* pSdrPage(pActiveGroupList->getSdrPageFromSdrObjList());
 341
 342                     if(nullptr != pSdrPage)
 343                     {
 344                         // It's a Page itself
 345                         return &(pSdrPage->GetViewContact());
 346                     }
 347                 }
 348             }
 349             else if(GetSdrPage())
 350             {
 351                 // use page of associated SdrPageView
 352                 return &(GetSdrPage()->GetViewContact());
 353             }
 354
 355             return nullptr;
 356         }
 357
 358         // Invalidate given rectangle at the window/output which is represented by
 359         // this ObjectContact.
 360         void ObjectContactOfPageView::InvalidatePartOfView(const basegfx::B2DRange& rRange) const
 361         {
 362             // invalidate at associated PageWindow
 363             GetPageWindow().InvalidatePageWindow(rRange);
 364         }
 365
 366         // Get info about the need to visualize GluePoints
 367         bool ObjectContactOfPageView::AreGluePointsVisible() const
 368         {
 369             bool bTiledRendering = comphelper::LibreOfficeKit::isActive();
 370             return !bTiledRendering && GetPageWindow().GetPageView().GetView().ImpIsGlueVisible();
 371         }
 372
 373         // check if text animation is allowed.
 374         bool ObjectContactOfPageView::IsTextAnimationAllowed() const
 375         {
 376             if (comphelper::IsFuzzing())
 377                 return true;
 378             // tdf#161765: Let the user choose which animation settings to use: OS's / LO's
 379             // New options: "System"/"No"/"Yes".
 380             // Do respect OS's animation setting if the user has selected the option "System"
 381             return MiscSettings::IsAnimatedTextAllowed();
 382         }
 383
 384         // check if graphic animation is allowed.
 385         bool ObjectContactOfPageView::IsGraphicAnimationAllowed() const
 386         {
 387             if (comphelper::IsFuzzing())
 388                 return true;
 389             // tdf#161765: Let the user choose which animation settings to use: OS's / LO's and
 390             // don't override here LO's animation settings with OS's all-or-nothing animation setting,
 391             // but do respect OS's animation setting if the user has selected the option "System".
 392             // New options: "System"/"No"/"Yes"
 393             return MiscSettings::IsAnimatedGraphicAllowed();
 394         }
 395
 396         // print?
 397         bool ObjectContactOfPageView::isOutputToPrinter() const
 398         {
 399             return (OUTDEV_PRINTER == mrPageWindow.GetPaintWindow().GetOutputDevice().GetOutDevType());
 400         }
 401
 402         // display page decoration? Default is true
 403         bool ObjectContactOfPageView::isPageDecorationActive() const
 404         {
 405             return GetPageWindow().GetPageView().GetView().IsPageDecorationAllowed();
 406         }
 407
 408         // display mster page content (ViewContactOfMasterPage)? Default is true
 409         bool ObjectContactOfPageView::isMasterPageActive() const
 410         {
 411             return GetPageWindow().GetPageView().GetView().IsMasterPageVisualizationAllowed();
 412         }
 413
 414         // recording MetaFile?
 415         bool ObjectContactOfPageView::isOutputToRecordingMetaFile() const
 416         {
 417             GDIMetaFile* pMetaFile = mrPageWindow.GetPaintWindow().GetOutputDevice().GetConnectMetaFile();
 418             return (pMetaFile && pMetaFile->IsRecord() && !pMetaFile->IsPause());
 419         }
 420
 421         // pdf export?
 422         bool ObjectContactOfPageView::isOutputToPDFFile() const
 423         {
 424             return OUTDEV_PDF == mrPageWindow.GetPaintWindow().GetOutputDevice().GetOutDevType();
 425         }
 426
 427         bool ObjectContactOfPageView::isExportTaggedPDF() const
 428         {
 429             if (isOutputToPDFFile())
 430             {
 431                 vcl::PDFExtOutDevData* pPDFExtOutDevData(dynamic_cast<vcl::PDFExtOutDevData*>(
 432                     mrPageWindow.GetPaintWindow().GetOutputDevice().GetExtOutDevData()));
 433
 434                 if (nullptr != pPDFExtOutDevData)
 435                 {
 436                     return pPDFExtOutDevData->GetIsExportTaggedPDF();
 437                 }
 438             }
 439             return false;
 440         }
 441
 442         ::vcl::PDFExtOutDevData const* ObjectContactOfPageView::GetPDFExtOutDevData() const
 443         {
 444             if (!isOutputToPDFFile())
 445             {
 446                 return nullptr;
 447             }
 448             vcl::PDFExtOutDevData* pPDFExtOutDevData(dynamic_cast<vcl::PDFExtOutDevData*>(
 449                 mrPageWindow.GetPaintWindow().GetOutputDevice().GetExtOutDevData()));
 450             return pPDFExtOutDevData;
 451         }
 452
 453         // gray display mode
 454         bool ObjectContactOfPageView::isDrawModeGray() const
 455         {
 456             const DrawModeFlags nDrawMode(mrPageWindow.GetPaintWindow().GetOutputDevice().GetDrawMode());
 457             return (nDrawMode == (DrawModeFlags::GrayLine|DrawModeFlags::GrayFill|DrawModeFlags::BlackText|DrawModeFlags::GrayBitmap|DrawModeFlags::GrayGradient));
 458         }
 459
 460         // high contrast display mode
 461         bool ObjectContactOfPageView::isDrawModeHighContrast() const
 462         {
 463             const DrawModeFlags nDrawMode(mrPageWindow.GetPaintWindow().GetOutputDevice().GetDrawMode());
 464             return (nDrawMode == (DrawModeFlags::SettingsLine|DrawModeFlags::SettingsFill|DrawModeFlags::SettingsText|DrawModeFlags::SettingsGradient));
 465         }
 466
 467         // access to SdrPageView
 468         SdrPageView* ObjectContactOfPageView::TryToGetSdrPageView() const
 469         {
 470             return &(mrPageWindow.GetPageView());
 471         }
 472
 473
 474         // access to OutputDevice
 475         OutputDevice* ObjectContactOfPageView::TryToGetOutputDevice() const
 476         {
 477             SdrPreRenderDevice* pPreRenderDevice = mrPageWindow.GetPaintWindow().GetPreRenderDevice();
 478
 479             if(pPreRenderDevice)
 480             {
 481                 return &(pPreRenderDevice->GetPreRenderDevice());
 482             }
 483             else
 484             {
 485                 return &(mrPageWindow.GetPaintWindow().GetOutputDevice());
 486             }
 487         }
 488
 489         // set all UNO controls displayed in the view to design/alive mode
 490         void ObjectContactOfPageView::SetUNOControlsDesignMode( bool _bDesignMode ) const
 491         {
 492             const sal_uInt32 nCount(getViewObjectContactCount());
 493
 494             for(sal_uInt32 a(0); a < nCount; a++)
 495             {
 496                 const ViewObjectContact* pVOC = getViewObjectContact(a);
 497                 const ViewObjectContactOfUnoControl* pUnoObjectVOC = dynamic_cast< const ViewObjectContactOfUnoControl* >(pVOC);
 498
 499                 if(pUnoObjectVOC)
 500                 {
 501                     pUnoObjectVOC->setControlDesignMode(_bDesignMode);
 502                 }
 503             }
 504         }
 505
 506 } // end of namespace
 507
 508 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */