viewobjectcontactofsdrpage.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
 
#include <sdr/contact/viewobjectcontactofsdrpage.hxx>
#include <svx/sdr/contact/displayinfo.hxx>
#include <sdr/contact/viewcontactofsdrpage.hxx>
#include <svx/svdview.hxx>
#include <svx/svdpage.hxx>
#include <svx/svdpagv.hxx>
#include <svx/sdr/contact/objectcontact.hxx>
#include <drawinglayer/primitive2d/backgroundcolorprimitive2d.hxx>
#include <basegfx/polygon/b2dpolygontools.hxx>
#include <drawinglayer/primitive2d/PolyPolygonColorPrimitive2D.hxx>
#include <drawinglayer/primitive2d/gridprimitive2d.hxx>
#include <drawinglayer/primitive2d/helplineprimitive2d.hxx>
#include <basegfx/polygon/b2dpolygon.hxx>
#include <sdr/primitive2d/sdrprimitivetools.hxx>
 
using namespace com::sun::star;
 
namespace sdr::contact {
 
const SdrPage& ViewObjectContactOfPageSubObject::getPage() const
{
    return static_cast< ViewContactOfPageSubObject& >(GetViewContact()).getPage();
}
 
ViewObjectContactOfPageSubObject::ViewObjectContactOfPageSubObject(ObjectContact& rObjectContact, ViewContact& rViewContact)
:   ViewObjectContact(rObjectContact, rViewContact)
{
}
 
ViewObjectContactOfPageSubObject::~ViewObjectContactOfPageSubObject()
{
}
 
bool ViewObjectContactOfPageSubObject::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
{
    if(rDisplayInfo.GetSubContentActive())
    {
        return false;
    }
 
    if(rDisplayInfo.GetControlLayerProcessingActive())
    {
        return false;
    }
 
    if(!rDisplayInfo.GetPageProcessingActive())
    {
        return false;
    }
 
    if(GetObjectContact().isOutputToPrinter())
    {
        return false;
    }
 
    if(!GetObjectContact().TryToGetSdrPageView())
    {
        return false;
    }
 
    return true;
}
 
bool ViewObjectContactOfPageSubObject::isPrimitiveGhosted(const DisplayInfo& /*rDisplayInfo*/) const
{
    // suppress ghosted for page parts
    return false;
}
 
ViewObjectContactOfPageBackground::ViewObjectContactOfPageBackground(ObjectContact& rObjectContact, ViewContact& rViewContact)
:   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
{
}
 
ViewObjectContactOfPageBackground::~ViewObjectContactOfPageBackground()
{
}
 
bool ViewObjectContactOfPageBackground::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
{
    if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
    {
        return false;
    }
 
    // no page background for preview renderers
    if(GetObjectContact().IsPreviewRenderer())
    {
        return false;
    }
 
    return true;
}
 
void ViewObjectContactOfPageBackground::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/, drawinglayer::primitive2d::Primitive2DDecompositionVisitor& rVisitor) const
{
    // Initialize background. Dependent of IsPageVisible, use ApplicationBackgroundColor or ApplicationDocumentColor. Most
    // old renderers for export (html, pdf, gallery, ...) set the page to not visible (SetPageVisible(false)). They expect the
    // given OutputDevice to be initialized with the ApplicationDocumentColor then.
    const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
 
    if(pPageView)
    {
        const SdrView& rView = pPageView->GetView();
        Color aInitColor;
 
        if(rView.IsPageVisible())
        {
            aInitColor = pPageView->GetApplicationBackgroundColor();
        }
        else
        {
            aInitColor = pPageView->GetApplicationDocumentColor();
 
            if(COL_AUTO == aInitColor)
            {
                const svtools::ColorConfig aColorConfig;
                aInitColor = aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor;
            }
        }
 
        // init background with InitColor
        const basegfx::BColor aRGBColor(aInitColor.getBColor());
        rVisitor.visit(new drawinglayer::primitive2d::BackgroundColorPrimitive2D(aRGBColor, (255 - aInitColor.GetAlpha()) / 255.0));
    }
}
 
ViewObjectContactOfMasterPage::ViewObjectContactOfMasterPage(ObjectContact& rObjectContact, ViewContact& rViewContact)
:   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
{
}
 
ViewObjectContactOfMasterPage::~ViewObjectContactOfMasterPage()
{
}
 
bool ViewObjectContactOfMasterPage::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
{
    if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
    {
        return false;
    }
 
    // this object is only used for MasterPages. When not the MasterPage is
    // displayed as a page, but another page is using it as sub-object, the
    // geometry needs to be hidden
    if(rDisplayInfo.GetSubContentActive())
    {
        return false;
    }
 
    return true;
}
 
ViewObjectContactOfPageFill::ViewObjectContactOfPageFill(ObjectContact& rObjectContact, ViewContact& rViewContact)
:   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
{
}
 
ViewObjectContactOfPageFill::~ViewObjectContactOfPageFill()
{
}
 
bool ViewObjectContactOfPageFill::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
{
    if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
    {
        return false;
    }
 
    SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 
    if(!pSdrPageView)
    {
        return false;
    }
 
    if(!pSdrPageView->GetView().IsPageVisible())
    {
        return false;
    }
 
    return true;
}
 
void ViewObjectContactOfPageFill::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/, drawinglayer::primitive2d::Primitive2DDecompositionVisitor& rVisitor) const
{
    const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
 
    if(pPageView)
    {
        const SdrPage& rPage = getPage();
 
        const basegfx::B2DRange aPageFillRange(0.0, 0.0, static_cast<double>(rPage.GetWidth()), static_cast<double>(rPage.GetHeight()));
        const basegfx::B2DPolygon aPageFillPolygon(basegfx::utils::createPolygonFromRect(aPageFillRange));
        Color aPageFillColor;
 
        if(pPageView->GetApplicationDocumentColor() != COL_AUTO)
        {
            aPageFillColor = pPageView->GetApplicationDocumentColor();
        }
        else
        {
            const svtools::ColorConfig aColorConfig;
            aPageFillColor = aColorConfig.GetColorValue(svtools::DOCCOLOR).nColor;
        }
 
        // create and add primitive
        const basegfx::BColor aRGBColor(aPageFillColor.getBColor());
        rVisitor.visit(new drawinglayer::primitive2d::PolyPolygonColorPrimitive2D(basegfx::B2DPolyPolygon(aPageFillPolygon), aRGBColor));
    }
}
 
ViewObjectContactOfPageShadow::ViewObjectContactOfPageShadow(ObjectContact& rObjectContact, ViewContact& rViewContact)
:   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
{
}
 
ViewObjectContactOfPageShadow::~ViewObjectContactOfPageShadow()
{
}
 
bool ViewObjectContactOfPageShadow::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
{
    if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
    {
        return false;
    }
 
    SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 
    if(!pSdrPageView)
    {
        return false;
    }
 
    if(!pSdrPageView->GetView().IsPageVisible())
    {
        return false;
    }
 
    if(!pSdrPageView->GetView().IsPageShadowVisible())
    {
        return false;
    }
 
    // no page shadow for preview renderers
    if(GetObjectContact().IsPreviewRenderer())
    {
        return false;
    }
 
    // no page shadow for high contrast mode
    if(GetObjectContact().isDrawModeHighContrast())
    {
        return false;
    }
 
    return true;
}
 
ViewObjectContactOfOuterPageBorder::ViewObjectContactOfOuterPageBorder(ObjectContact& rObjectContact, ViewContact& rViewContact)
:   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
{
}
 
ViewObjectContactOfOuterPageBorder::~ViewObjectContactOfOuterPageBorder()
{
}
 
bool ViewObjectContactOfOuterPageBorder::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
{
    if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
    {
        return false;
    }
 
    SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 
    if(!pSdrPageView)
    {
        return false;
    }
 
    const SdrView& rView = pSdrPageView->GetView();
 
    return rView.IsPageVisible() || !rView.IsPageBorderVisible();
}
 
ViewObjectContactOfInnerPageBorder::ViewObjectContactOfInnerPageBorder(ObjectContact& rObjectContact, ViewContact& rViewContact)
:   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
{
}
 
ViewObjectContactOfInnerPageBorder::~ViewObjectContactOfInnerPageBorder()
{
}
 
bool ViewObjectContactOfInnerPageBorder::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
{
    if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
    {
        return false;
    }
 
    SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 
    if(!pSdrPageView)
    {
        return false;
    }
 
    if(!pSdrPageView->GetView().IsBordVisible())
    {
        return false;
    }
 
    const SdrPage& rPage = getPage();
 
    if(!rPage.GetLeftBorder() && !rPage.GetUpperBorder() && !rPage.GetRightBorder() && !rPage.GetLowerBorder())
    {
        return false;
    }
 
    // no inner page border for preview renderers
    if(GetObjectContact().IsPreviewRenderer())
    {
        return false;
    }
 
    return true;
}
 
ViewObjectContactOfPageHierarchy::ViewObjectContactOfPageHierarchy(ObjectContact& rObjectContact, ViewContact& rViewContact)
:   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
{
}
 
ViewObjectContactOfPageHierarchy::~ViewObjectContactOfPageHierarchy()
{
}
 
void ViewObjectContactOfPageHierarchy::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo, drawinglayer::primitive2d::Primitive2DDecompositionVisitor& rVisitor) const
{
    // process local sub-hierarchy
    const sal_uInt32 nSubHierarchyCount(GetViewContact().GetObjectCount());
 
    if(!nSubHierarchyCount)
        return;
 
    getPrimitive2DSequenceSubHierarchy(rDisplayInfo, rVisitor);
}
 
ViewObjectContactOfPageGrid::ViewObjectContactOfPageGrid(ObjectContact& rObjectContact, ViewContact& rViewContact)
:   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
{
}
 
ViewObjectContactOfPageGrid::~ViewObjectContactOfPageGrid()
{
}
 
bool ViewObjectContactOfPageGrid::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
{
    if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
    {
        return false;
    }
 
    SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 
    if(!pSdrPageView)
    {
        return false;
    }
 
    const SdrView& rView = pSdrPageView->GetView();
 
    if(!rView.IsGridVisible())
    {
        return false;
    }
 
    // no page grid for preview renderers
    if(GetObjectContact().IsPreviewRenderer())
    {
        return false;
    }
 
    if(static_cast< ViewContactOfGrid& >(GetViewContact()).getFront() != rView.IsGridFront())
    {
        return false;
    }
 
    return true;
}
 
void ViewObjectContactOfPageGrid::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/, drawinglayer::primitive2d::Primitive2DDecompositionVisitor& rVisitor) const
{
    const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
 
    if(pPageView)
    {
        const SdrView& rView = pPageView->GetView();
        const SdrPage& rPage = getPage();
        const Color aGridColor(rView.GetGridColor());
        const basegfx::BColor aRGBGridColor(aGridColor.getBColor());
 
        basegfx::B2DHomMatrix aGridMatrix;
        aGridMatrix.set(0, 0, static_cast<double>(rPage.GetWidth() - (rPage.GetRightBorder() + rPage.GetLeftBorder())));
        aGridMatrix.set(1, 1, static_cast<double>(rPage.GetHeight() - (rPage.GetLowerBorder() + rPage.GetUpperBorder())));
        aGridMatrix.set(0, 2, static_cast<double>(rPage.GetLeftBorder()));
        aGridMatrix.set(1, 2, static_cast<double>(rPage.GetUpperBorder()));
 
        const Size aRaw(rView.GetGridCoarse());
        const Size aFine(rView.GetGridFine());
        const double fWidthX(aRaw.getWidth());
        const double fWidthY(aRaw.getHeight());
        const sal_uInt32 nSubdivisionsX(aFine.getWidth() ? aRaw.getWidth() / aFine.getWidth() : 0);
        const sal_uInt32 nSubdivisionsY(aFine.getHeight() ? aRaw.getHeight() / aFine.getHeight() : 0);
 
        rVisitor.visit(new drawinglayer::primitive2d::GridPrimitive2D(
            aGridMatrix, fWidthX, fWidthY, 10.0, 3.0, nSubdivisionsX, nSubdivisionsY, aRGBGridColor,
            drawinglayer::primitive2d::createDefaultCross_3x3(aRGBGridColor)));
    }
}
 
ViewObjectContactOfPageHelplines::ViewObjectContactOfPageHelplines(ObjectContact& rObjectContact, ViewContact& rViewContact)
:   ViewObjectContactOfPageSubObject(rObjectContact, rViewContact)
{
}
 
ViewObjectContactOfPageHelplines::~ViewObjectContactOfPageHelplines()
{
}
 
bool ViewObjectContactOfPageHelplines::isPrimitiveVisible(const DisplayInfo& rDisplayInfo) const
{
    if(!ViewObjectContactOfPageSubObject::isPrimitiveVisible(rDisplayInfo))
    {
        return false;
    }
 
    SdrPageView* pSdrPageView = GetObjectContact().TryToGetSdrPageView();
 
    if(!pSdrPageView)
    {
        return false;
    }
 
    const SdrView& rView = pSdrPageView->GetView();
 
    if(!rView.IsHlplVisible())
    {
        return false;
    }
 
    // no helplines for preview renderers
    if(GetObjectContact().IsPreviewRenderer())
    {
        return false;
    }
 
    if(static_cast< ViewContactOfHelplines& >(GetViewContact()).getFront() != rView.IsHlplFront())
    {
        return false;
    }
 
    return true;
}
 
void ViewObjectContactOfPageHelplines::createPrimitive2DSequence(const DisplayInfo& /*rDisplayInfo*/, drawinglayer::primitive2d::Primitive2DDecompositionVisitor& rVisitor) const
{
    const SdrPageView* pPageView = GetObjectContact().TryToGetSdrPageView();
 
    if(pPageView)
    {
        const SdrHelpLineList& rHelpLineList = pPageView->GetHelpLines();
        const sal_uInt32 nCount(rHelpLineList.GetCount());
 
        if(nCount)
        {
            const basegfx::BColor aRGBColorA(1.0, 1.0, 1.0);
            const basegfx::BColor aRGBColorB(0.0, 0.0, 0.0);
 
            for(sal_uInt32 a(0); a < nCount; a++)
            {
                const SdrHelpLine& rHelpLine = rHelpLineList[static_cast<sal_uInt16>(a)];
                const basegfx::B2DPoint aPosition(static_cast<double>(rHelpLine.GetPos().X()), static_cast<double>(rHelpLine.GetPos().Y()));
                const double fDiscreteDashLength(4.0);
 
                switch(rHelpLine.GetKind())
                {
                    default : // SdrHelpLineKind::Point
                    {
                        rVisitor.visit(new drawinglayer::primitive2d::HelplinePrimitive2D(
                            aPosition, basegfx::B2DVector(1.0, 0.0), drawinglayer::primitive2d::HelplineStyle2D::Point,
                            aRGBColorA, aRGBColorB, fDiscreteDashLength));
                        break;
                    }
                    case SdrHelpLineKind::Vertical :
                    {
                        rVisitor.visit(new drawinglayer::primitive2d::HelplinePrimitive2D(
                            aPosition, basegfx::B2DVector(0.0, 1.0), drawinglayer::primitive2d::HelplineStyle2D::Line,
                            aRGBColorA, aRGBColorB, fDiscreteDashLength));
                        break;
                    }
                    case SdrHelpLineKind::Horizontal :
                    {
                        rVisitor.visit(new drawinglayer::primitive2d::HelplinePrimitive2D(
                            aPosition, basegfx::B2DVector(1.0, 0.0), drawinglayer::primitive2d::HelplineStyle2D::Line,
                            aRGBColorA, aRGBColorB, fDiscreteDashLength));
                        break;
                    }
                }
            }
        }
    }
}
 
ViewObjectContactOfSdrPage::ViewObjectContactOfSdrPage(ObjectContact& rObjectContact, ViewContact& rViewContact)
:   ViewObjectContact(rObjectContact, rViewContact)
{
}
 
ViewObjectContactOfSdrPage::~ViewObjectContactOfSdrPage()
{
}
 
void ViewObjectContactOfSdrPage::getPrimitive2DSequenceHierarchy(DisplayInfo& rDisplayInfo, drawinglayer::primitive2d::Primitive2DDecompositionVisitor& rVisitor) const
{
    // process local sub-hierarchy
    const sal_uInt32 nSubHierarchyCount(GetViewContact().GetObjectCount());
 
    if(!nSubHierarchyCount)
        return;
 
    const bool bDoGhostedDisplaying(
        GetObjectContact().DoVisualizeEnteredGroup()
        && !GetObjectContact().isOutputToPrinter()
        && GetObjectContact().getActiveViewContact() == &GetViewContact());
 
    if(bDoGhostedDisplaying)
    {
        rDisplayInfo.ClearGhostedDrawMode();
    }
 
    // visit object hierarchy
    getPrimitive2DSequenceSubHierarchy(rDisplayInfo, rVisitor);
 
    if(bDoGhostedDisplaying)
    {
        rDisplayInfo.SetGhostedDrawMode();
    }
}
 
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */