    /* -*- 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 <cmdid.h>
    #include <hintids.hxx>
    #include <algorithm>
    #include <svl/eitem.hxx>
    #include <tools/fract.hxx>
    #include <editeng/lrspitem.hxx>
    #include <editeng/ulspitem.hxx>
    #include <editeng/sizeitem.hxx>
    #include <svx/pageitem.hxx>
    #include <editeng/brushitem.hxx>
    #include <editeng/frmdiritem.hxx>
    #include <vcl/bitmap.hxx>
    #include <vcl/builder.hxx>
    #include <vcl/graph.hxx>
    #include <vcl/settings.hxx>
    #include <vcl/builderfactory.hxx>
    #include <tgrditem.hxx>
    #include <viewopt.hxx>
    #include <colex.hxx>
    #include <colmgr.hxx>
    #include <svx/unobrushitemhelper.hxx>
    #include <svx/svxids.hrc>

    void SwPageExample::UpdateExample( const SfxItemSet& rSet )
    {
        if (SfxItemState::DEFAULT <= rSet.GetItemState(RES_FRAMEDIR))
        {
            const SvxFrameDirectionItem& rDirItem = rSet.Get(RES_FRAMEDIR);
            m_bVertical = rDirItem.GetValue() == SvxFrameDirection::Vertical_RL_TB||
                        rDirItem.GetValue() == SvxFrameDirection::Vertical_LR_TB;
        }

        SfxItemPool* pPool = rSet.GetPool();
        sal_uInt16 nWhich = pPool->GetWhich( SID_ATTR_PAGE );
        if ( rSet.GetItemState( nWhich, false ) == SfxItemState::SET )
        {
            // alignment
            const SvxPageItem* pPage = static_cast<const SvxPageItem*>(&rSet.Get( nWhich ));

            if ( pPage )
                SetUsage( pPage->GetPageUsage() );
        }

        nWhich = pPool->GetWhich( SID_ATTR_PAGE_SIZE );

        if ( rSet.GetItemState( nWhich, false ) == SfxItemState::SET )
        {
            // orientation and size from PageItem
            const SvxSizeItem& rSize = static_cast<const SvxSizeItem&>(rSet.Get( nWhich ));
            SetSize( rSize.GetSize() );
        }
        nWhich = RES_LR_SPACE;
        if ( rSet.GetItemState( nWhich, false ) == SfxItemState::SET )
        {
            // set left and right border
            const SvxLRSpaceItem& rLRSpace = static_cast<const SvxLRSpaceItem&>(rSet.Get( nWhich ));

            SetLeft( rLRSpace.GetLeft() );
            SetRight( rLRSpace.GetRight() );
        }
        else
        {
            SetLeft( 0 );
            SetRight( 0 );
        }

        nWhich = RES_UL_SPACE;

        if ( rSet.GetItemState( nWhich, false ) == SfxItemState::SET )
        {
            // set upper and lower border
            const SvxULSpaceItem& rULSpace = static_cast<const SvxULSpaceItem&>(rSet.Get( nWhich ));

            SetTop( rULSpace.GetUpper() );
            SetBottom( rULSpace.GetLower() );
        }
        else
        {
            SetTop( 0 );
            SetBottom( 0 );
        }

        // evaluate header-attributes
        const SfxPoolItem* pItem;
        if( SfxItemState::SET == rSet.GetItemState( pPool->GetWhich( SID_ATTR_PAGE_HEADERSET),
                false, &pItem ) )
        {
            const SfxItemSet& rHeaderSet = static_cast<const SvxSetItem*>(pItem)->GetItemSet();
            const SfxBoolItem& rHeaderOn =
                static_cast<const SfxBoolItem&>(rHeaderSet.Get( pPool->GetWhich( SID_ATTR_PAGE_ON ) ) );

            if ( rHeaderOn.GetValue() )
            {
                const SvxSizeItem& rSize =
                    static_cast<const SvxSizeItem&>(rHeaderSet.Get(pPool->GetWhich(SID_ATTR_PAGE_SIZE)));

                const SvxULSpaceItem& rUL = static_cast<const SvxULSpaceItem&>(rHeaderSet.Get(
                                            pPool->GetWhich(SID_ATTR_ULSPACE)));
                const SvxLRSpaceItem& rLR = static_cast<const SvxLRSpaceItem&>(rHeaderSet.Get(
                                            pPool->GetWhich(SID_ATTR_LRSPACE)));

                SetHdHeight( rSize.GetSize().Height() - rUL.GetLower());
                SetHdDist( rUL.GetLower() );
                SetHdLeft( rLR.GetLeft() );
                SetHdRight( rLR.GetRight() );
                SetHeader( true );

                if(SfxItemState::SET == rHeaderSet.GetItemState(RES_BACKGROUND))
                {
                    // create FillAttributes from SvxBrushItem //SetHdColor(rItem.GetColor());
                    const SvxBrushItem& rItem = rHeaderSet.Get(RES_BACKGROUND);
                    SfxItemSet aTempSet(*rHeaderSet.GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{});

                    setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet);
                    setHeaderFillAttributes(
                        std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(
                                aTempSet));
                }
            }
            else
                SetHeader( false );
        }

        if( SfxItemState::SET == rSet.GetItemState( pPool->GetWhich( SID_ATTR_PAGE_FOOTERSET),
                false, &pItem ) )
        {
            const SfxItemSet& rFooterSet = static_cast<const SvxSetItem*>(pItem)->GetItemSet();
            const SfxBoolItem& rFooterOn = rFooterSet.Get( SID_ATTR_PAGE_ON );

            if ( rFooterOn.GetValue() )
            {
                const SvxSizeItem& rSize =
                    static_cast<const SvxSizeItem&>(rFooterSet.Get( pPool->GetWhich( SID_ATTR_PAGE_SIZE ) ));

                const SvxULSpaceItem& rUL = static_cast<const SvxULSpaceItem&>(rFooterSet.Get(
                                            pPool->GetWhich( SID_ATTR_ULSPACE ) ));
                const SvxLRSpaceItem& rLR = static_cast<const SvxLRSpaceItem&>(rFooterSet.Get(
                                            pPool->GetWhich( SID_ATTR_LRSPACE ) ));

                SetFtHeight( rSize.GetSize().Height() - rUL.GetUpper());
                SetFtDist( rUL.GetUpper() );
                SetFtLeft( rLR.GetLeft() );
                SetFtRight( rLR.GetRight() );
                SetFooter( true );

                if( rFooterSet.GetItemState( RES_BACKGROUND ) == SfxItemState::SET )
                {
                    // create FillAttributes from SvxBrushItem //SetFtColor(rItem.GetColor());
                    const SvxBrushItem& rItem = rFooterSet.Get(RES_BACKGROUND);
                    SfxItemSet aTempSet(*rFooterSet.GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{});

                    setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet);
                    setFooterFillAttributes(
                        std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(
                                aTempSet));
                }
            }
            else
                SetFooter( false );
        }

        if(SfxItemState::SET == rSet.GetItemState(RES_BACKGROUND, false, &pItem))
        {
            // create FillAttributes from SvxBrushItem
            const SvxBrushItem& rItem = static_cast< const SvxBrushItem& >(*pItem);
            SfxItemSet aTempSet(*rSet.GetPool(), svl::Items<XATTR_FILL_FIRST, XATTR_FILL_LAST>{});

            setSvxBrushItemAsFillAttributesToTargetSet(rItem, aTempSet);
            setPageFillAttributes(
                std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(
                        aTempSet));
        }

        Invalidate();
    }

    void SwColExample::DrawPage(vcl::RenderContext& rRenderContext, const Point& rOrg,
                                const bool bSecond, const bool bEnabled)
    {
        SwPageExample::DrawPage(rRenderContext, rOrg, bSecond, bEnabled);
        if (!pColMgr)
            return;
        sal_uInt16 nColumnCount = pColMgr->GetCount();
        if (!nColumnCount)
            return;

        long nL = GetLeft();
        long nR = GetRight();

        if (GetUsage() == SvxPageUsage::Mirror && !bSecond)
        {
            // swap for mirrored
            nL = GetRight();
            nR = GetLeft();
        }

        rRenderContext.SetFillColor(COL_LIGHTGRAY);
        tools::Rectangle aRect;
        aRect.SetRight( rOrg.X() + GetSize().Width() - nR );
        aRect.SetLeft( rOrg.X() + nL );
        aRect.SetTop( rOrg.Y() + GetTop() + GetHdHeight() + GetHdDist() );
        aRect.SetBottom( rOrg.Y() + GetSize().Height() - GetBottom() - GetFtHeight() - GetFtDist() );
        rRenderContext.DrawRect(aRect);

        const tools::Rectangle aDefineRect(aRect);
        const drawinglayer::attribute::SdrAllFillAttributesHelperPtr& rFillAttributes = getPageFillAttributes();

        if (!rFillAttributes.get() || !rFillAttributes->isUsed())
        {
            // If there is no fill, use fallback color
            const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
            const Color& rFieldColor = rStyleSettings.GetFieldColor();

            setPageFillAttributes(
                std::make_shared<drawinglayer::attribute::SdrAllFillAttributesHelper>(
                    rFieldColor));
        }

        // #97495# make sure that the automatic column width's are always equal
        bool bAutoWidth = pColMgr->IsAutoWidth();
        sal_Int32 nAutoColWidth = 0;
        if (bAutoWidth)
        {
            sal_Int32 nColumnWidthSum = 0;
            for (sal_uInt16 i = 0; i < nColumnCount; ++i)
                nColumnWidthSum += pColMgr->GetColWidth( i );
            nAutoColWidth = nColumnWidthSum / nColumnCount;
        }

        for (sal_uInt16 i = 0; i < nColumnCount; ++i)
        {
            if (!bAutoWidth)
                nAutoColWidth = pColMgr->GetColWidth(i);

            if (!m_bVertical)
                aRect.SetRight( aRect.Left() + nAutoColWidth );
            else
                aRect.SetBottom( aRect.Top() + nAutoColWidth );

            // use primitive draw command
            drawFillAttributes(rRenderContext, getPageFillAttributes(), aRect, aDefineRect);

            if (i < nColumnCount - 1)
            {
                if (!m_bVertical)
                    aRect.SetLeft( aRect.Right() + pColMgr->GetGutterWidth(i) );
                else
                    aRect.SetTop( aRect.Bottom() + pColMgr->GetGutterWidth(i) );
            }
        }
        if (pColMgr->HasLine())
        {
            Point aUp(rOrg.X() + nL, rOrg.Y() + GetTop());
            Point aDown(rOrg.X() + nL,
                            rOrg.Y() + GetSize().Height() - GetBottom() - GetFtHeight() - GetFtDist());

            if (pColMgr->GetLineHeightPercent() != 100)
            {
                long nLength = !m_bVertical ? aDown.Y() - aUp.Y() : aDown.X() - aUp.X();
                nLength -= nLength * pColMgr->GetLineHeightPercent() / 100;
                switch (pColMgr->GetAdjust())
                {
                    case COLADJ_BOTTOM:
                        if (!m_bVertical)
                            aUp.AdjustY(nLength );
                        else
                            aUp.AdjustX(nLength );
                        break;
                    case COLADJ_TOP:
                        if (!m_bVertical)
                            aDown.AdjustY( -nLength );
                        else
                            aDown.AdjustX( -nLength );
                        break;
                    case COLADJ_CENTER:
                        if (!m_bVertical)
                        {
                            aUp.AdjustY(nLength / 2 );
                            aDown.AdjustY( -(nLength / 2) );
                        }
                        else
                        {
                            aUp.AdjustX(nLength / 2 );
                            aDown.AdjustX( -(nLength / 2) );
                        }
                        break;
                    default:
                        break; // prevent warning
                }
            }

            for (sal_uInt16 i = 0; i < nColumnCount -  1; ++i)
            {
                int nGutter = pColMgr->GetGutterWidth(i);
                int nDist = pColMgr->GetColWidth( i ) + nGutter;
                nDist -= (i == 0) ? nGutter / 2 : 0;
                if (!m_bVertical)
                {
                    aUp.AdjustX(nDist );
                    aDown.AdjustX(nDist );
                }
                else
                {
                    aUp.AdjustY(nDist );
                    aDown.AdjustY(nDist );
                }

                rRenderContext.DrawLine(aUp, aDown);
            }
        }
    }

    SwColumnOnlyExample::SwColumnOnlyExample()
        : m_aFrameSize(SvxPaperInfo::GetPaperSize(PAPER_A4)) // DIN A4
    {
        ::FitToActualSize(m_aCols, static_cast<sal_uInt16>(m_aFrameSize.Width()));
    }

    void SwColumnOnlyExample::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& /*rRect*/)
    {
        rRenderContext.Push(PushFlags::MAPMODE);

        Fraction aScale(m_aWinSize.Height(), m_aFrameSize.Height());
        MapMode aMapMode(MapUnit::MapTwip);
        aMapMode.SetScaleX(aScale);
        aMapMode.SetScaleY(aScale);
        rRenderContext.SetMapMode(aMapMode);

        const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
        const Color& rFieldColor = rStyleSettings.GetFieldColor();
        const Color& rDlgColor = rStyleSettings.GetDialogColor();
        const Color& rFieldTextColor = SwViewOption::GetFontColor();
        Color aGrayColor(COL_LIGHTGRAY);
        if (rFieldColor == aGrayColor)
            aGrayColor.Invert();

        Size aLogSize(rRenderContext.PixelToLogic(GetOutputSizePixel()));
        tools::Rectangle aCompleteRect(Point(0,0), aLogSize);
        rRenderContext.SetLineColor(rDlgColor);
        rRenderContext.SetFillColor(rDlgColor);
        rRenderContext.DrawRect(aCompleteRect);

        rRenderContext.SetLineColor(rFieldTextColor);
        Point aTL((aLogSize.Width() - m_aFrameSize.Width()) / 2,
                  (aLogSize.Height() - m_aFrameSize.Height()) / 2);
        tools::Rectangle aRect(aTL, m_aFrameSize);

        //draw a shadow rectangle
        rRenderContext.SetFillColor(COL_GRAY);
        tools::Rectangle aShadowRect(aRect);
        aShadowRect.Move(aTL.Y(), aTL.Y());
        rRenderContext.DrawRect(aShadowRect);

        rRenderContext.SetFillColor(rFieldColor);
        rRenderContext.DrawRect(aRect);

        rRenderContext.SetFillColor(aGrayColor);

        //column separator?
        long nLength = aLogSize.Height() - 2 * aTL.Y();
        Point aUp(aTL);
        Point aDown(aTL.X(), nLength);
        bool bLines = false;
        if (m_aCols.GetLineAdj() != COLADJ_NONE)
        {
            bLines = true;

            sal_uInt16 nPercent = m_aCols.GetLineHeight();
            if (nPercent != 100)
            {
                nLength -= nLength * nPercent / 100;
                switch(m_aCols.GetLineAdj())
                {
                    case COLADJ_BOTTOM: aUp.AdjustY(nLength ); break;
                    case COLADJ_TOP: aDown.AdjustY( -nLength ); break;
                    case COLADJ_CENTER:
                            aUp.AdjustY(nLength / 2 );
                            aDown.AdjustY( -(nLength / 2) );
                    break;
                    default:
                        break; //prevent warning
                }
            }

        }
        const SwColumns& rCols = m_aCols.GetColumns();
        sal_uInt16 nColCount = rCols.size();
        if (nColCount)
        {
            rRenderContext.DrawRect(aRect);
            rRenderContext.SetFillColor(rFieldColor);
            tools::Rectangle aFrameRect(aTL, m_aFrameSize);
            long nSum = aTL.X();
            for (sal_uInt16 i = 0; i < nColCount; i++)
            {
                const SwColumn* pCol = &rCols[i];
                aFrameRect.SetLeft( nSum + pCol->GetLeft() ); //nSum + pCol->GetLeft() + aTL.X();
                nSum += pCol->GetWishWidth();
                aFrameRect.SetRight( nSum - pCol->GetRight() );
                rRenderContext.DrawRect(aFrameRect);
            }
            if (bLines)
            {
                nSum = aTL.X();
                for (sal_uInt16 i = 0; i < nColCount - 1; i++)
                {
                    nSum += rCols[i].GetWishWidth();
                    aUp.setX( nSum );
                    aDown.setX( nSum );
                    rRenderContext.DrawLine(aUp, aDown);
                }
            }
        }
        rRenderContext.Pop();
    }

    void  SwColumnOnlyExample::SetColumns(const SwFormatCol& rCol)
    {
        m_aCols = rCol;
        sal_uInt16 nWishSum = m_aCols.GetWishWidth();
        long nFrameWidth = m_aFrameSize.Width();
        SwColumns& rCols = m_aCols.GetColumns();
        sal_uInt16 nColCount = rCols.size();

        for(sal_uInt16 i = 0; i < nColCount; i++)
        {
            SwColumn* pCol = &rCols[i];
            long nWish = pCol->GetWishWidth();
            nWish *= nFrameWidth;
            nWish /= nWishSum;
            pCol->SetWishWidth(static_cast<sal_uInt16>(nWish));
            long nLeft = pCol->GetLeft();
            nLeft *= nFrameWidth;
            nLeft /= nWishSum;
            pCol->SetLeft(static_cast<sal_uInt16>(nLeft));
            long nRight = pCol->GetRight();
            nRight *= nFrameWidth;
            nRight /= nWishSum;
            pCol->SetRight(static_cast<sal_uInt16>(nRight));
        }
        // #97495# make sure that the automatic column width's are always equal
        if(nColCount && m_aCols.IsOrtho())
        {
            sal_Int32 nColumnWidthSum = 0;
            sal_uInt16 i;
            for(i = 0; i < nColCount; ++i)
            {
                SwColumn* pCol = &rCols[i];
                nColumnWidthSum += pCol->GetWishWidth();
                nColumnWidthSum -= (pCol->GetRight() + pCol->GetLeft());
            }
            nColumnWidthSum /= nColCount;
            for(i = 0; i < nColCount; ++i)
            {
                SwColumn* pCol = &rCols[i];
                pCol->SetWishWidth( static_cast< sal_uInt16 >(nColumnWidthSum + pCol->GetRight() + pCol->GetLeft()));
            }
        }
    }

    void SwColumnOnlyExample::SetDrawingArea(weld::DrawingArea* pDrawingArea)
    {
        weld::CustomWidgetController::SetDrawingArea(pDrawingArea);
        OutputDevice& rRefDevice = pDrawingArea->get_ref_device();
        Size aPrefSize(rRefDevice.LogicToPixel(Size(75, 46), MapMode(MapUnit::MapAppFont)));
        pDrawingArea->set_size_request(aPrefSize.Width(), aPrefSize.Height());
    }

    void SwColumnOnlyExample::Resize()
    {
        OutputDevice& rRefDevice = GetDrawingArea()->get_ref_device();
        rRefDevice.Push(PushFlags::MAPMODE);
        rRefDevice.SetMapMode(MapMode(MapUnit::MapTwip));
        m_aWinSize = GetOutputSizePixel();
        m_aWinSize.AdjustHeight( -4 );
        m_aWinSize.AdjustWidth( -4 );
        m_aWinSize = rRefDevice.PixelToLogic(m_aWinSize);
        rRefDevice.Pop();
        Invalidate();
    }

    SwPageGridExample::SwPageGridExample()
    {
    }

    void SwPageGridExample::DrawPage(vcl::RenderContext& rRenderContext, const Point& rOrg,
                                     const bool bSecond, const bool bEnabled)
    {
        SwPageExample::DrawPage(rRenderContext, rOrg, bSecond, bEnabled);

        if (!pGridItem || !pGridItem->GetGridType())
            return;

        //paint the grid now
        Color aLineColor = pGridItem->GetColor();
        if (aLineColor == COL_AUTO)
        {
            aLineColor = rRenderContext.GetFillColor();
            aLineColor.Invert();
        }
        rRenderContext.SetLineColor(aLineColor);
        long nL = GetLeft();
        long nR = GetRight();

        if (GetUsage() == SvxPageUsage::Mirror && !bSecond)
        {
            // rotate for mirrored
            nL = GetRight();
            nR = GetLeft();
        }

        tools::Rectangle aRect;
        aRect.SetRight( rOrg.X() + GetSize().Width() - nR );
        aRect.SetLeft( rOrg.X() + nL );
        aRect.SetTop( rOrg.Y() + GetTop() + GetHdHeight() + GetHdDist() );
        aRect.SetBottom( rOrg.Y() + GetSize().Height() - GetBottom() - GetFtHeight() - GetFtDist() );

        //increase the values to get a 'viewable' preview
        sal_Int32 nBaseHeight = pGridItem->GetBaseHeight() * 3;
        sal_Int32 nRubyHeight = pGridItem->GetRubyHeight() * 3;

        //detect height of rectangles
        tools::Rectangle aRubyRect(aRect.TopLeft(),
                    m_bVertical ?
                    Size(nRubyHeight, aRect.GetHeight()) :
                    Size(aRect.GetWidth(), nRubyHeight));
        tools::Rectangle aCharRect(aRect.TopLeft(),
                    m_bVertical ?
                    Size(nBaseHeight, aRect.GetHeight()) :
                    Size(aRect.GetWidth(), nBaseHeight));

        sal_Int32 nLineHeight = nBaseHeight + nRubyHeight;

        //detect count of rectangles
        sal_Int32 nLines = (m_bVertical ? aRect.GetWidth(): aRect.GetHeight()) / nLineHeight;
        if (nLines > pGridItem->GetLines())
            nLines = pGridItem->GetLines();

        // determine start position
        if (m_bVertical)
        {
            sal_Int16 nXStart = static_cast<sal_Int16>(aRect.GetWidth() / 2 - nLineHeight * nLines /2);
            aRubyRect.Move(nXStart, 0);
            aCharRect.Move(nXStart, 0);
        }
        else
        {
            sal_Int16 nYStart = static_cast<sal_Int16>(aRect.GetHeight() / 2 - nLineHeight * nLines /2);
            aRubyRect.Move(0, nYStart);
            aCharRect.Move(0, nYStart);
        }

        if (pGridItem->IsRubyTextBelow())
            m_bVertical ? aRubyRect.Move(nBaseHeight, 0) : aRubyRect.Move(0, nBaseHeight);
        else
            m_bVertical ? aCharRect.Move(nRubyHeight, 0) : aCharRect.Move(0, nRubyHeight);

        //vertical lines
        bool bBothLines = pGridItem->GetGridType() == GRID_LINES_CHARS;
        rRenderContext.SetFillColor(COL_TRANSPARENT);
        sal_Int32 nXMove = m_bVertical ? nLineHeight : 0;
        sal_Int32 nYMove = m_bVertical ? 0 : nLineHeight;
        for (sal_Int32 nLine = 0; nLine < nLines; nLine++)
        {
            rRenderContext.DrawRect(aRubyRect);
            rRenderContext.DrawRect(aCharRect);
            if (bBothLines)
            {
                Point aStart = aCharRect.TopLeft();
                Point aEnd = m_bVertical ? aCharRect.TopRight() : aCharRect.BottomLeft();
                while (m_bVertical ? aStart.Y() < aRect.Bottom(): aStart.X() < aRect.Right())
                {
                    rRenderContext.DrawLine(aStart, aEnd);
                    if (m_bVertical)
                        aStart.setY( aEnd.AdjustY(nBaseHeight ) );
                    else
                        aStart.setX( aEnd.AdjustX(nBaseHeight ) );
                }
            }
            aRubyRect.Move(nXMove, nYMove);
            aCharRect.Move(nXMove, nYMove);
        }

    }

    void SwPageGridExample::UpdateExample( const SfxItemSet& rSet )
    {
        pGridItem.reset();
        //get the grid information
        if (SfxItemState::DEFAULT <= rSet.GetItemState(RES_TEXTGRID))
            pGridItem.reset(static_cast<SwTextGridItem*>(rSet.Get(RES_TEXTGRID).Clone()));
        SwPageExample::UpdateExample(rSet);
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V1029 Numeric Truncation Error. Result of the 'size' function is written to the 16-bit variable.

↑ V547 Expression 'pPage' is always true.

↑ V1029 Numeric Truncation Error. Result of the 'size' function is written to the 16-bit variable.