/* -*- 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 <config_features.h>

#include <DrawViewShell.hxx>
#include <svx/svdpagv.hxx>
#include <svx/xfillit0.hxx>
#include <svx/xlineit0.hxx>
#include <svx/xlnwtit.hxx>
#include <svx/xlndsit.hxx>
#include <svx/xflhtit.hxx>
#include <svx/xflgrit.hxx>
#include <svx/xlnclit.hxx>
#include <svx/xflclit.hxx>
#include <sfx2/bindings.hxx>

#include <sfx2/dispatch.hxx>
#include <svl/intitem.hxx>
#include <sfx2/request.hxx>
#include <svl/stritem.hxx>
#include <svx/svxids.hrc>
#include <svx/xtable.hxx>
#include <vcl/graph.hxx>
#include <svx/svdograf.hxx>
#include <svl/whiter.hxx>
#include <basic/sbstar.hxx>
#include <basic/sberrors.hxx>

#include <sfx2/viewfrm.hxx>

#include <app.hrc>
#include <strings.hrc>
#include <Window.hxx>
#include <drawdoc.hxx>
#include <drawview.hxx>
#include <DrawDocShell.hxx>
#include <sdresid.hxx>

#include <svx/galleryitem.hxx>
#include <com/sun/star/gallery/GalleryItemType.hpp>
#include <com/sun/star/drawing/LineStyle.hpp>
#include <memory>

using namespace com::sun::star;

namespace sd {

void DrawViewShell::ExecGallery(SfxRequest const & rReq)
{
    // nothing is executed during a slide show!
    if(HasCurrentFunction(SID_PRESENTATION))
        return;

    const SfxItemSet* pArgs = rReq.GetArgs();

    const SvxGalleryItem* pGalleryItem = SfxItemSet::GetItem<SvxGalleryItem>(pArgs, SID_GALLERY_FORMATS, false);
    if ( !pGalleryItem )
        return;

    GetDocSh()->SetWaitCursor( true );

    sal_Int8 nType( pGalleryItem->GetType() );
    // insert graphic
    if (nType == css::gallery::GalleryItemType::GRAPHIC)
    {
        Graphic aGraphic( pGalleryItem->GetGraphic() );

        // reduce size if necessary
        ScopedVclPtrInstance< Window > aWindow(GetActiveWindow());
        aWindow->SetMapMode(aGraphic.GetPrefMapMode());
        Size aSizePix = aWindow->LogicToPixel(aGraphic.GetPrefSize());
        aWindow->SetMapMode( MapMode(MapUnit::Map100thMM) );
        Size aSize = aWindow->PixelToLogic(aSizePix);

        // constrain size to page size if necessary
        SdrPage* pPage = mpDrawView->GetSdrPageView()->GetPage();
        Size aPageSize = pPage->GetSize();
        aPageSize.AdjustWidth( -(pPage->GetLeftBorder() + pPage->GetRightBorder()) );
        aPageSize.AdjustHeight( -(pPage->GetUpperBorder() + pPage->GetLowerBorder()) );

        // If the image is too large we make it fit into the page
        if ( ( ( aSize.Height() > aPageSize.Height() ) || ( aSize.Width()   > aPageSize.Width() ) ) &&
            aSize.Height() && aPageSize.Height() )
        {
            float fGrfWH =  static_cast<float>(aSize.Width()) /
                            static_cast<float>(aSize.Height());
            float fWinWH =  static_cast<float>(aPageSize.Width()) /
                            static_cast<float>(aPageSize.Height());

            // constrain size to page size if necessary
            if ((fGrfWH != 0.F) && (fGrfWH < fWinWH))
            {
                aSize.setWidth( static_cast<::tools::Long>(aPageSize.Height() * fGrfWH) );
                aSize.setHeight( aPageSize.Height() );
            }
            else
            {
                aSize.setWidth( aPageSize.Width() );
                aSize.setHeight( static_cast<::tools::Long>(aPageSize.Width() / fGrfWH) );
            }
        }

        // set output rectangle for graphic
        Point aPnt ((aPageSize.Width()  - aSize.Width())  / 2,
                    (aPageSize.Height() - aSize.Height()) / 2);
        aPnt += Point(pPage->GetLeftBorder(), pPage->GetUpperBorder());
        ::tools::Rectangle aRect (aPnt, aSize);

        rtl::Reference<SdrGrafObj> pGrafObj;

        bool bInsertNewObject = true;

        const SdrMarkList& rMarkList = mpDrawView->GetMarkedObjectList();
        if ( rMarkList.GetMarkCount() != 0 )
        {
            // is there an empty graphic object?
            if (rMarkList.GetMarkCount() == 1)
            {
                SdrMark* pMark = rMarkList.GetMark(0);
                SdrObject* pObj = pMark->GetMarkedSdrObj();

                if (pObj->GetObjInventor() == SdrInventor::Default && pObj->GetObjIdentifier() == SdrObjKind::Graphic)
                {
                    pGrafObj = static_cast<SdrGrafObj*>(pObj);

                    if( pGrafObj->IsEmptyPresObj() )
                    {
                        // the empty graphic object gets a new graphic
                        bInsertNewObject = false;

                        rtl::Reference<SdrGrafObj> pNewGrafObj(SdrObject::Clone(*pGrafObj, pGrafObj->getSdrModelFromSdrObject()));
                        pNewGrafObj->SetEmptyPresObj(false);
                        pNewGrafObj->SetOutlinerParaObject(std::nullopt);
                        pNewGrafObj->SetGraphic(aGraphic);

                        OUString aStr = rMarkList.GetMarkDescription() +
                            " " + SdResId(STR_UNDO_REPLACE);
                        mpDrawView->BegUndo(aStr);
                        SdrPageView* pPV = mpDrawView->GetSdrPageView();
                        mpDrawView->ReplaceObjectAtView(pGrafObj.get(), *pPV, pNewGrafObj.get());
                        mpDrawView->EndUndo();
                    }
                }
            }
        }

        if( bInsertNewObject )
        {
            pGrafObj = new SdrGrafObj(
                GetView()->getSdrModelFromSdrView(),
                aGraphic,
                aRect);
            SdrPageView* pPV = mpDrawView->GetSdrPageView();
            mpDrawView->InsertObjectAtView(pGrafObj.get(), *pPV, SdrInsertFlags::SETDEFLAYER);
        }
    }
    // insert sound
    else if( nType == css::gallery::GalleryItemType::MEDIA )
    {
        const SfxStringItem aMediaURLItem( SID_INSERT_AVMEDIA, pGalleryItem->GetURL() );
        GetViewFrame()->GetDispatcher()->ExecuteList(SID_INSERT_AVMEDIA,
                SfxCallMode::SYNCHRON, { &aMediaURLItem });
    }

    GetDocSh()->SetWaitCursor( false );
}

/**
 * Edit macros for attribute configuration
 */

/* the work flow to adjust the attributes is nearly everywhere the same
   1. read existing attributes
   2. read parameter from the basic-set
   3. delete selected item from the attribute-set
   4. create new attribute-item
   5. insert item into set      */
void DrawViewShell::AttrExec (SfxRequest &rReq)
{
    // nothing is executed during a slide show!
    if(HasCurrentFunction(SID_PRESENTATION))
        return;

    CheckLineTo (rReq);

    SfxBindings&    rBindings = GetViewFrame()->GetBindings();
    SfxItemSet aAttr( GetDoc()->GetPool() );

    GetView()->GetAttributes( aAttr );
    const SfxItemSet* pArgs = rReq.GetArgs();

    switch (rReq.GetSlot ())
    {
        // set new fill-style
        case SID_SETFILLSTYLE :
            if (pArgs && pArgs->Count () == 1)
            {
                const SfxUInt32Item* pFillStyle = rReq.GetArg<SfxUInt32Item>(ID_VAL_STYLE);
                if (CHECK_RANGE (drawing::FillStyle_NONE, static_cast<drawing::FillStyle>(pFillStyle->GetValue ()), drawing::FillStyle_BITMAP))
                {
                    aAttr.ClearItem (XATTR_FILLSTYLE);
                    XFillStyleItem aStyleItem(static_cast<drawing::FillStyle>(pFillStyle->GetValue ()));
                    aStyleItem.SetWhich(XATTR_FILLSTYLE);
                    aAttr.Put (aStyleItem);
                    rBindings.Invalidate (SID_ATTR_FILL_STYLE);
                    rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
                }
#if HAVE_FEATURE_SCRIPTING
                else StarBASIC::FatalError (ERRCODE_BASIC_BAD_PROP_VALUE);
#endif
                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        // determine new line style
        case SID_SETLINESTYLE :
            if (pArgs && pArgs->Count () == 1)
            {
                const SfxUInt32Item* pLineStyle = rReq.GetArg<SfxUInt32Item>(ID_VAL_STYLE);
                if (CHECK_RANGE (sal_Int32(drawing::LineStyle_NONE), static_cast<sal_Int32>(pLineStyle->GetValue()), sal_Int32(drawing::LineStyle_DASH)))
                {
                    aAttr.ClearItem (XATTR_LINESTYLE);
                    XLineStyleItem aStyleItem(static_cast<drawing::LineStyle>(pLineStyle->GetValue()));
                    aStyleItem.SetWhich(XATTR_LINESTYLE);
                    aAttr.Put(aStyleItem);
                    rBindings.Invalidate (SID_ATTR_LINE_STYLE);
                }
#if HAVE_FEATURE_SCRIPTING
                else StarBASIC::FatalError (ERRCODE_BASIC_BAD_PROP_VALUE);
#endif
                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        // set line width
        case SID_SETLINEWIDTH :
            if (pArgs && pArgs->Count () == 1)
            {
                const SfxUInt32Item* pLineWidth = rReq.GetArg<SfxUInt32Item>(ID_VAL_WIDTH);
                aAttr.ClearItem (XATTR_LINEWIDTH);
                XLineWidthItem aWidthItem(pLineWidth->GetValue());
                aWidthItem.SetWhich(XATTR_LINEWIDTH);
                aAttr.Put(aWidthItem);
                rBindings.Invalidate (SID_ATTR_LINE_WIDTH);
                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        case SID_SETFILLCOLOR :
            if (pArgs && pArgs->Count () == 3)
            {
                const SfxUInt32Item* pRed = rReq.GetArg<SfxUInt32Item>(ID_VAL_RED);
                const SfxUInt32Item* pGreen = rReq.GetArg<SfxUInt32Item>(ID_VAL_GREEN);
                const SfxUInt32Item* pBlue = rReq.GetArg<SfxUInt32Item>(ID_VAL_BLUE);

                aAttr.ClearItem (XATTR_FILLCOLOR);
                aAttr.ClearItem (XATTR_FILLSTYLE);
                XFillColorItem aColorItem(-1, Color (static_cast<sal_uInt8>(pRed->GetValue ()),
                                                       static_cast<sal_uInt8>(pGreen->GetValue ()),
                                                       static_cast<sal_uInt8>(pBlue->GetValue ())));
                aColorItem.SetWhich(XATTR_FILLCOLOR);
                aAttr.Put(aColorItem);
                rBindings.Invalidate (SID_ATTR_FILL_COLOR);
                rBindings.Invalidate (SID_ATTR_PAGE_COLOR);
                rBindings.Invalidate (SID_ATTR_FILL_STYLE);
                rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        case SID_SETLINECOLOR :
            if (pArgs && pArgs->Count () == 3)
            {
                const SfxUInt32Item* pRed = rReq.GetArg<SfxUInt32Item>(ID_VAL_RED);
                const SfxUInt32Item* pGreen = rReq.GetArg<SfxUInt32Item>(ID_VAL_GREEN);
                const SfxUInt32Item* pBlue = rReq.GetArg<SfxUInt32Item>(ID_VAL_BLUE);

                aAttr.ClearItem (XATTR_LINECOLOR);
                XLineColorItem aColorItem(-1, Color(static_cast<sal_uInt8>(pRed->GetValue()),
                                                    static_cast<sal_uInt8>(pGreen->GetValue()),
                                                    static_cast<sal_uInt8>(pBlue->GetValue())));
                aColorItem.SetWhich(XATTR_LINECOLOR);
                aAttr.Put(aColorItem);
                rBindings.Invalidate (SID_ATTR_LINE_COLOR);
                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        case SID_SETGRADSTARTCOLOR :
        case SID_SETGRADENDCOLOR :
            if (pArgs && pArgs->Count () == 4)
            {
                const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
                const SfxUInt32Item* pRed = rReq.GetArg<SfxUInt32Item>(ID_VAL_RED);
                const SfxUInt32Item* pGreen = rReq.GetArg<SfxUInt32Item>(ID_VAL_GREEN);
                const SfxUInt32Item* pBlue = rReq.GetArg<SfxUInt32Item>(ID_VAL_BLUE);
                assert(pName && pRed && pGreen && pBlue && "must be present");

                XGradientListRef pGradientList = GetDoc()->GetGradientList ();
                ::tools::Long          nCounts        = pGradientList->Count ();
                Color         aColor (static_cast<sal_uInt8>(pRed->GetValue ()),
                                      static_cast<sal_uInt8>(pGreen->GetValue ()),
                                      static_cast<sal_uInt8>(pBlue->GetValue ()));
                ::tools::Long i;

                aAttr.ClearItem (XATTR_FILLGRADIENT);
                aAttr.ClearItem (XATTR_FILLSTYLE);

                for ( i = 0; i < nCounts; i ++)
                {
                    const XGradientEntry* pEntry = pGradientList->GetGradient(i);

                    if (pEntry->GetName () == pName->GetValue ())
                    {
                        basegfx::BGradient aGradient(pEntry->GetGradient());
                        basegfx::BColorStops aNewColorStops(aGradient.GetColorStops());

                        if (SID_SETGRADSTARTCOLOR == rReq.GetSlot ())
                        {
                            aNewColorStops.replaceStartColor(aColor.getBColor());
                        }
                        else
                        {
                            aNewColorStops.replaceEndColor(aColor.getBColor());
                        }

                        aGradient.SetColorStops(aNewColorStops);

                        XFillStyleItem aStyleItem(drawing::FillStyle_GRADIENT);
                        aStyleItem.SetWhich(XATTR_FILLSTYLE);
                        aAttr.Put(aStyleItem);
                        XFillGradientItem aGradientItem(pName->GetValue (), aGradient);
                        aGradientItem.SetWhich(XATTR_FILLGRADIENT);
                        aAttr.Put(aGradientItem);
                        break;
                    }
                }

                if (i >= nCounts)
                {
                    Color aBlack (0, 0, 0);
                    basegfx::BGradient aGradient (
                        basegfx::BColorStops(
                            (rReq.GetSlot () == SID_SETGRADSTARTCOLOR)
                                             ? aColor.getBColor()
                                             : aBlack.getBColor(),
                            (rReq.GetSlot () == SID_SETGRADENDCOLOR)
                                             ? aColor.getBColor()
                                             : aBlack.getBColor()));

                    GetDoc()->GetGradientList()->Insert(std::make_unique<XGradientEntry>(aGradient, pName->GetValue()));

                    XFillStyleItem aStyleItem(drawing::FillStyle_GRADIENT);
                    aStyleItem.SetWhich(XATTR_FILLSTYLE);
                    aAttr.Put(aStyleItem);
                    XFillGradientItem aGradientItem(pName->GetValue(), aGradient);
                    aGradientItem.SetWhich(XATTR_FILLGRADIENT);
                    aAttr.Put(aGradientItem);
                }

                rBindings.Invalidate (SID_ATTR_FILL_STYLE);
                rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
                rBindings.Invalidate (SID_ATTR_FILL_GRADIENT);
                rBindings.Invalidate (SID_ATTR_PAGE_GRADIENT);
                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        case SID_SETHATCHCOLOR :
            if (pArgs && pArgs->Count () == 4)
            {
                const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
                const SfxUInt32Item* pRed = rReq.GetArg<SfxUInt32Item>(ID_VAL_RED);
                const SfxUInt32Item* pGreen = rReq.GetArg<SfxUInt32Item>(ID_VAL_GREEN);
                const SfxUInt32Item* pBlue = rReq.GetArg<SfxUInt32Item>(ID_VAL_BLUE);
                assert(pName && pRed && pGreen && pBlue && "must be present");

                XHatchListRef pHatchList = GetDoc()->GetHatchList ();
                ::tools::Long       nCounts     = pHatchList->Count ();
                Color      aColor (static_cast<sal_uInt8>(pRed->GetValue ()),
                                   static_cast<sal_uInt8>(pGreen->GetValue ()),
                                   static_cast<sal_uInt8>(pBlue->GetValue ()));
                ::tools::Long i;

                aAttr.ClearItem (XATTR_FILLHATCH);
                aAttr.ClearItem (XATTR_FILLSTYLE);

                for ( i = 0; i < nCounts; i ++)
                {
                    const XHatchEntry* pEntry = pHatchList->GetHatch(i);

                    if (pEntry->GetName () == pName->GetValue ())
                    {
                        XHatch aHatch(pEntry->GetHatch());

                        aHatch.SetColor (aColor);

                        XFillStyleItem aStyleItem(drawing::FillStyle_HATCH);
                        aStyleItem.SetWhich(XATTR_FILLSTYLE);
                        aAttr.Put(aStyleItem);
                        XFillHatchItem aHatchItem(pName->GetValue(), aHatch);
                        aHatchItem.SetWhich(XATTR_FILLHATCH);
                        aAttr.Put(aHatchItem);
                        break;
                    }
                }

                if (i >= nCounts)
                {
                    XHatch aHatch (aColor);

                    GetDoc()->GetHatchList()->Insert(std::make_unique<XHatchEntry>(aHatch, pName->GetValue()));

                    XFillStyleItem aStyleItem(drawing::FillStyle_HATCH);
                    aStyleItem.SetWhich(XATTR_FILLSTYLE);
                    aAttr.Put(aStyleItem);
                    XFillHatchItem aHatchItem(pName->GetValue (), aHatch);
                    aHatchItem.SetWhich(XATTR_FILLHATCH);
                    aAttr.Put(aHatchItem);
                }

                rBindings.Invalidate (SID_ATTR_FILL_HATCH);
                rBindings.Invalidate (SID_ATTR_PAGE_HATCH);
                rBindings.Invalidate (SID_ATTR_FILL_STYLE);
                rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        // configuration for line-dash
        case SID_DASH :
            if (pArgs && pArgs->Count () == 7)
            {
                const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
                const SfxUInt32Item* pStyle = rReq.GetArg<SfxUInt32Item>(ID_VAL_STYLE);
                const SfxUInt32Item* pDots = rReq.GetArg<SfxUInt32Item>(ID_VAL_DOTS);
                const SfxUInt32Item* pDotLen = rReq.GetArg<SfxUInt32Item>(ID_VAL_DOTLEN);
                const SfxUInt32Item* pDashes = rReq.GetArg<SfxUInt32Item>(ID_VAL_DASHES);
                const SfxUInt32Item* pDashLen = rReq.GetArg<SfxUInt32Item>(ID_VAL_DASHLEN);
                const SfxUInt32Item* pDistance = rReq.GetArg<SfxUInt32Item>(ID_VAL_DISTANCE);
                assert(pName && pStyle && pDots && pDotLen && pDashes && pDashLen && pDistance && "must be present");

                if (CHECK_RANGE (sal_Int32(css::drawing::DashStyle_RECT), static_cast<sal_Int32>(pStyle->GetValue()), sal_Int32(css::drawing::DashStyle_ROUNDRELATIVE)))
                {
                    XDash aNewDash (static_cast<css::drawing::DashStyle>(pStyle->GetValue ()), static_cast<short>(pDots->GetValue ()), pDotLen->GetValue (),
                                    static_cast<short>(pDashes->GetValue ()), pDashLen->GetValue (), pDistance->GetValue ());

                    aAttr.ClearItem (XATTR_LINEDASH);
                    aAttr.ClearItem (XATTR_LINESTYLE);

                    XDashListRef pDashList = GetDoc()->GetDashList();
                    ::tools::Long       nCounts    = pDashList->Count ();
                    std::unique_ptr<XDashEntry> pEntry = std::make_unique<XDashEntry>(aNewDash, pName->GetValue());
                    ::tools::Long i;

                    for ( i = 0; i < nCounts; i++ )
                        if (pDashList->GetDash (i)->GetName () == pName->GetValue ())
                            break;

                    if (i < nCounts)
                        pDashList->Replace(std::move(pEntry), i);
                    else
                        pDashList->Insert(std::move(pEntry));

                    XLineDashItem aDashItem(pName->GetValue(), aNewDash);
                    aDashItem.SetWhich(XATTR_LINEDASH);
                    aAttr.Put(aDashItem);
                    XLineStyleItem aStyleItem(drawing::LineStyle_DASH);
                    aStyleItem.SetWhich(XATTR_LINESTYLE);
                    aAttr.Put(aStyleItem);
                    rBindings.Invalidate (SID_ATTR_LINE_DASH);
                    rBindings.Invalidate (SID_ATTR_FILL_STYLE);
                }
#if HAVE_FEATURE_SCRIPTING
                else StarBASIC::FatalError (ERRCODE_BASIC_BAD_PROP_VALUE);
#endif
                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        // configuration for gradients
        case SID_GRADIENT :
            if (pArgs && pArgs->Count () == 8)
            {
                const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
                const SfxUInt32Item* pStyle = rReq.GetArg<SfxUInt32Item>(ID_VAL_STYLE);
                const SfxUInt32Item* pAngle = rReq.GetArg<SfxUInt32Item>(ID_VAL_ANGLE);
                const SfxUInt32Item* pBorder = rReq.GetArg<SfxUInt32Item>(ID_VAL_BORDER);
                const SfxUInt32Item* pCenterX = rReq.GetArg<SfxUInt32Item>(ID_VAL_CENTER_X);
                const SfxUInt32Item* pCenterY = rReq.GetArg<SfxUInt32Item>(ID_VAL_CENTER_Y);
                const SfxUInt32Item* pStart = rReq.GetArg<SfxUInt32Item>(ID_VAL_STARTINTENS);
                const SfxUInt32Item* pEnd = rReq.GetArg<SfxUInt32Item>(ID_VAL_ENDINTENS);
                assert(pName && pStyle && pAngle && pBorder && pCenterX && pCenterY && pStart && pEnd && "must be present");

                if (CHECK_RANGE (sal_Int32(css::awt::GradientStyle_LINEAR), static_cast<sal_Int32>(pStyle->GetValue()), sal_Int32(css::awt::GradientStyle_RECT)) &&
                    CHECK_RANGE (0, static_cast<sal_Int32>(pAngle->GetValue ()), 360) &&
                    CHECK_RANGE (0, static_cast<sal_Int32>(pBorder->GetValue ()), 100) &&
                    CHECK_RANGE (0, static_cast<sal_Int32>(pCenterX->GetValue ()), 100) &&
                    CHECK_RANGE (0, static_cast<sal_Int32>(pCenterY->GetValue ()), 100) &&
                    CHECK_RANGE (0, static_cast<sal_Int32>(pStart->GetValue ()), 100) &&
                    CHECK_RANGE (0, static_cast<sal_Int32>(pEnd->GetValue ()), 100))
                {
                    aAttr.ClearItem (XATTR_FILLGRADIENT);
                    aAttr.ClearItem (XATTR_FILLSTYLE);

                    XGradientListRef pGradientList = GetDoc()->GetGradientList ();
                    ::tools::Long           nCounts        = pGradientList->Count ();
                    ::tools::Long i;

                    for ( i = 0; i < nCounts; i++ )
                    {
                        const XGradientEntry* pEntry = pGradientList->GetGradient(i);

                        if (pEntry->GetName () == pName->GetValue ())
                        {
                            basegfx::BGradient aGradient(pEntry->GetGradient());

                            aGradient.SetGradientStyle (static_cast<css::awt::GradientStyle>(pStyle->GetValue ()));
                            aGradient.SetAngle (Degree10(pAngle->GetValue () * 10));
                            aGradient.SetBorder (static_cast<short>(pBorder->GetValue ()));
                            aGradient.SetXOffset (static_cast<short>(pCenterX->GetValue ()));
                            aGradient.SetYOffset (static_cast<short>(pCenterY->GetValue ()));
                            aGradient.SetStartIntens (static_cast<short>(pStart->GetValue ()));
                            aGradient.SetEndIntens (static_cast<short>(pEnd->GetValue ()));

                            XFillStyleItem aStyleItem(drawing::FillStyle_GRADIENT);
                            aStyleItem.SetWhich(XATTR_FILLSTYLE);
                            aAttr.Put(aStyleItem);
                            XFillGradientItem aGradientItem(pName->GetValue (), aGradient);
                            aGradientItem.SetWhich(XATTR_FILLGRADIENT);
                            aAttr.Put(aGradientItem);
                            break;
                        }
                    }

                    if (i >= nCounts)
                    {
                        Color aBlack (0, 0, 0);
                        basegfx::BGradient aGradient (
                            basegfx::BColorStops(aBlack.getBColor(), aBlack.getBColor()),
                            static_cast<css::awt::GradientStyle>(pStyle->GetValue ()),
                            Degree10(pAngle->GetValue () * 10), static_cast<short>(pCenterX->GetValue ()),
                            static_cast<short>(pCenterY->GetValue ()), static_cast<short>(pBorder->GetValue ()),
                            static_cast<short>(pStart->GetValue ()), static_cast<short>(pEnd->GetValue ()));

                        pGradientList->Insert(std::make_unique<XGradientEntry>(aGradient, pName->GetValue()));
                        XFillStyleItem aStyleItem(drawing::FillStyle_GRADIENT);
                        aStyleItem.SetWhich(XATTR_FILLSTYLE);
                        aAttr.Put(aStyleItem);
                        XFillGradientItem aGradientItem(pName->GetValue (), aGradient);
                        aGradientItem.SetWhich(XATTR_FILLGRADIENT);
                        aAttr.Put(aGradientItem);
                    }

                    rBindings.Invalidate (SID_ATTR_FILL_GRADIENT);
                    rBindings.Invalidate (SID_ATTR_PAGE_GRADIENT);
                    rBindings.Invalidate (SID_ATTR_FILL_STYLE);
                    rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
                }
#if HAVE_FEATURE_SCRIPTING
                else StarBASIC::FatalError (ERRCODE_BASIC_BAD_PROP_VALUE);
#endif
                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        // configuration for hatch
        case SID_HATCH :
            if (pArgs && pArgs->Count () == 4)
            {
                const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
                const SfxUInt32Item* pStyle = rReq.GetArg<SfxUInt32Item>(ID_VAL_STYLE);
                const SfxUInt32Item* pDistance = rReq.GetArg<SfxUInt32Item>(ID_VAL_DISTANCE);
                const SfxUInt32Item* pAngle = rReq.GetArg<SfxUInt32Item>(ID_VAL_ANGLE);
                assert(pName && pStyle && pDistance && pAngle && "must be present");

                if (CHECK_RANGE (sal_Int32(css::drawing::HatchStyle_SINGLE), static_cast<sal_Int32>(pStyle->GetValue()), sal_Int32(css::drawing::HatchStyle_TRIPLE)) &&
                    CHECK_RANGE (0, static_cast<sal_Int32>(pAngle->GetValue ()), 360))
                {
                    aAttr.ClearItem (XATTR_FILLHATCH);
                    aAttr.ClearItem (XATTR_FILLSTYLE);

                    XHatchListRef pHatchList = GetDoc()->GetHatchList ();
                    ::tools::Long       nCounts     = pHatchList->Count ();
                    ::tools::Long i;

                    for ( i = 0; i < nCounts; i++ )
                    {
                        const XHatchEntry* pEntry = pHatchList->GetHatch(i);

                        if (pEntry->GetName () == pName->GetValue ())
                        {
                            XHatch aHatch(pEntry->GetHatch());

                            aHatch.SetHatchStyle (static_cast<css::drawing::HatchStyle>(pStyle->GetValue ()));
                            aHatch.SetDistance (pDistance->GetValue ());
                            aHatch.SetAngle (Degree10(pAngle->GetValue () * 10));

                            XFillStyleItem aStyleItem(drawing::FillStyle_HATCH);
                            aStyleItem.SetWhich(XATTR_FILLSTYLE);
                            aAttr.Put(aStyleItem);
                            XFillHatchItem aHatchItem(pName->GetValue (), aHatch);
                            aHatchItem.SetWhich(XATTR_FILLHATCH);
                            aAttr.Put(aHatchItem);
                            break;
                        }
                    }

                    if (i >= nCounts)
                    {
                        XHatch aHatch (Color(0), static_cast<css::drawing::HatchStyle>(pStyle->GetValue ()), pDistance->GetValue (),
                                       Degree10(pAngle->GetValue () * 10));

                        pHatchList->Insert(std::make_unique<XHatchEntry>(aHatch, pName->GetValue()));
                        XFillStyleItem aStyleItem(drawing::FillStyle_HATCH);
                        aStyleItem.SetWhich(XATTR_FILLSTYLE);
                        aAttr.Put(aStyleItem);
                        XFillHatchItem aHatchItem(pName->GetValue (), aHatch);
                        aHatchItem.SetWhich(XATTR_FILLHATCH);
                        aAttr.Put(aHatchItem);
                    }

                    rBindings.Invalidate (SID_ATTR_FILL_HATCH);
                    rBindings.Invalidate (SID_ATTR_FILL_STYLE);
                }
#if HAVE_FEATURE_SCRIPTING
                else StarBASIC::FatalError (ERRCODE_BASIC_BAD_PROP_VALUE);
#endif
                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        case SID_SELECTGRADIENT :
            if (pArgs && (pArgs->Count() == 1))
            {
                const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
                assert(pName && "must be present");

                XGradientListRef pGradientList = GetDoc()->GetGradientList ();
                ::tools::Long           nCounts        = pGradientList->Count ();

                for (::tools::Long i = 0; i < nCounts; i ++)
                {
                    const XGradientEntry* pEntry = pGradientList->GetGradient(i);

                    if (pEntry->GetName () == pName->GetValue ())
                    {
                        aAttr.ClearItem (XATTR_FILLGRADIENT);
                        aAttr.ClearItem (XATTR_FILLSTYLE);
                        XFillStyleItem aStyleItem(drawing::FillStyle_GRADIENT);
                        aStyleItem.SetWhich(XATTR_FILLSTYLE);
                        aAttr.Put(aStyleItem);
                        XFillGradientItem aGradientItem(pName->GetValue (), pEntry->GetGradient ());
                        aGradientItem.SetWhich(XATTR_FILLGRADIENT);
                        aAttr.Put(aGradientItem);
                        rBindings.Invalidate (SID_ATTR_FILL_GRADIENT);
                        rBindings.Invalidate (SID_ATTR_PAGE_GRADIENT);
                        rBindings.Invalidate (SID_ATTR_FILL_STYLE);
                        rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
                        break;
                    }
                }

                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        case SID_SELECTHATCH :
            if (pArgs && pArgs->Count() == 1)
            {
                const SfxStringItem* pName = rReq.GetArg<SfxStringItem>(ID_VAL_INDEX);
                assert(pName && "must be present");

                XHatchListRef pHatchList = GetDoc()->GetHatchList ();
                ::tools::Long       nCounts     = pHatchList->Count ();

                for (::tools::Long i = 0; i < nCounts; i ++)
                {
                    const XHatchEntry* pEntry = pHatchList->GetHatch(i);

                    if (pEntry->GetName () == pName->GetValue ())
                    {
                        aAttr.ClearItem (XATTR_FILLHATCH);
                        aAttr.ClearItem (XATTR_FILLSTYLE);
                        XFillStyleItem aStyleItem(drawing::FillStyle_HATCH);
                        aStyleItem.SetWhich(XATTR_FILLSTYLE);
                        aAttr.Put(aStyleItem);
                        XFillHatchItem aHatchItem(pName->GetValue (), pEntry->GetHatch ());
                        aHatchItem.SetWhich(XATTR_FILLHATCH);
                        aAttr.Put(aHatchItem);

                        rBindings.Invalidate (SID_ATTR_FILL_HATCH);
                        rBindings.Invalidate (SID_ATTR_PAGE_HATCH);
                        rBindings.Invalidate (SID_ATTR_FILL_STYLE);
                        rBindings.Invalidate (SID_ATTR_PAGE_FILLSTYLE);
                        break;
                    }
                }

                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

        case SID_UNSELECT :
            mpDrawView->UnmarkAll ();
            break;

        case SID_GETRED :
            if (pArgs && pArgs->Count () == 1)
            {
                break;
            }
#if HAVE_FEATURE_SCRIPTING
            StarBASIC::FatalError (ERRCODE_BASIC_WRONG_ARGS);
#endif
            break;

/*        case SID_SETFONTFAMILYNAME :
        case SID_SETFONTSTYLENAME :
        case SID_SETFONTFAMILY :
        case SID_SETFONTPITCH :
        case SID_SETFONTCHARSET :
        case SID_SETFONTPOSTURE :
        case SID_SETFONTWEIGHT :
        case SID_SETFONTUNDERLINE :
        case SID_SETFONTCROSSEDOUT :
        case SID_SETFONTSHADOWED :
        case SID_SETFONTCONTOUR :
        case SID_SETFONTCOLOR :
        case SID_SETFONTLANGUAGE :
        case SID_SETFONTWORDLINE :
        case SID_SETFONTCASEMAP :
        case SID_SETFONTESCAPE :
        case SID_SETFONTKERNING :
            break;*/

        default :
            ;
    }

    mpDrawView->SetAttributes (const_cast<const SfxItemSet &>(aAttr));
    rReq.Ignore ();
}

/**
 * Edit macros for attribute configuration
 */
void DrawViewShell::AttrState (SfxItemSet& rSet)
{
    SfxWhichIter     aIter (rSet);
    sal_uInt16           nWhich = aIter.FirstWhich ();
    SfxItemSet aAttr( GetDoc()->GetPool() );
    mpDrawView->GetAttributes( aAttr );

    while (nWhich)
    {
        switch (nWhich)
        {
            case SID_GETFILLSTYLE :
            {
                const XFillStyleItem &rFillStyleItem = aAttr.Get (XATTR_FILLSTYLE);

                rSet.Put (SfxUInt32Item (nWhich, static_cast<::tools::Long>(rFillStyleItem.GetValue ())));
                break;
            }

            case SID_GETLINESTYLE :
            {
                const XLineStyleItem &rLineStyleItem = aAttr.Get (XATTR_LINESTYLE);

                rSet.Put (SfxUInt32Item (nWhich, static_cast<::tools::Long>(rLineStyleItem.GetValue ())));
                break;
            }

            case SID_GETLINEWIDTH :
            {
                const XLineWidthItem &rLineWidthItem = aAttr.Get (XATTR_LINEWIDTH);

                rSet.Put (SfxUInt32Item (nWhich, static_cast<::tools::Long>(rLineWidthItem.GetValue ())));
                break;
            }

            case SID_GETGREEN :
            case SID_GETRED :
            case SID_GETBLUE :
            {
                const SfxUInt32Item &rWhatKind = static_cast<const SfxUInt32Item &>( rSet.Get (ID_VAL_WHATKIND) );
                Color               aColor;

                switch (rWhatKind.GetValue ())
                {
                    case 1 :
                    {
                        const XLineColorItem &rLineColorItem = aAttr.Get (XATTR_LINECOLOR);

                        aColor = rLineColorItem.GetColorValue ();
                        break;
                    }

                    case 2 :
                    {
                        const XFillColorItem &rFillColorItem = aAttr.Get (XATTR_FILLCOLOR);

                        aColor = rFillColorItem.GetColorValue ();
                        break;
                    }

                    case 3 :
                    case 4 :
                    {
                        const XFillGradientItem &rFillGradientItem = aAttr.Get (XATTR_FILLGRADIENT);
                        const basegfx::BGradient &rGradient = rFillGradientItem.GetGradientValue ();

                        aColor = (rWhatKind.GetValue () == 3)
                                    ? Color(rGradient.GetColorStops().front().getStopColor())
                                    : Color(rGradient.GetColorStops().back().getStopColor());
                        break;
                    }

                    case 5:
                    {
                        const XFillHatchItem &rFillHatchItem = aAttr.Get (XATTR_FILLHATCH);
                        const XHatch         &rHatch         = rFillHatchItem.GetHatchValue ();

                        aColor = rHatch.GetColor ();
                        break;
                    }

                    default :
                        ;
                }

                rSet.Put (SfxUInt32Item (nWhich, static_cast<::tools::Long>((nWhich == SID_GETRED)
                                                             ? aColor.GetRed ()
                                                             : (nWhich == SID_GETGREEN)
                                                                   ? aColor.GetGreen ()
                                                                   : aColor.GetBlue ())));
                break;
            }

            default :
                ;
        }

        nWhich = aIter.NextWhich ();
    }
}

} // end of namespace sd

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
3-7</option>
<option value='libreoffice-7-4'>libreoffice-7-4</option>
<option value='libreoffice-7-4-0'>libreoffice-7-4-0</option>
<option value='libreoffice-7-4-1'>libreoffice-7-4-1</option>
<option value='libreoffice-7-4-2'>libreoffice-7-4-2</option>
<option value='libreoffice-7-4-3'>libreoffice-7-4-3</option>
<option value='libreoffice-7-4-4'>libreoffice-7-4-4</option>
<option value='libreoffice-7-4-6'>libreoffice-7-4-6</option>
<option value='libreoffice-7-4-7'>libreoffice-7-4-7</option>
<option value='libreoffice-7-5'>libreoffice-7-5</option>
<option value='libreoffice-7-5-0'>libreoffice-7-5-0</option>
<option value='libreoffice-7-5-1'>libreoffice-7-5-1</option>
<option value='libreoffice-7-5-2'>libreoffice-7-5-2</option>
<option value='libreoffice-7-5-3'>libreoffice-7-5-3</option>
<option value='libreoffice-7-5-4'>libreoffice-7-5-4</option>
<option value='libreoffice-7-5-5'>libreoffice-7-5-5</option>
<option value='libreoffice-7-5-6'>libreoffice-7-5-6</option>
<option value='libreoffice-7-5-7'>libreoffice-7-5-7</option>
<option value='libreoffice-7-5-8'>libreoffice-7-5-8</option>
<option value='libreoffice-7-5-9'>libreoffice-7-5-9</option>
<option value='libreoffice-7-6'>libreoffice-7-6</option>
<option value='libreoffice-7-6-0'>libreoffice-7-6-0</option>
<option value='libreoffice-7-6-1'>libreoffice-7-6-1</option>
<option value='libreoffice-7-6-2'>libreoffice-7-6-2</option>
<option value='libreoffice-7-6-3'>libreoffice-7-6-3</option>
<option value='libreoffice-7-6-4'>libreoffice-7-6-4</option>
<option value='libreoffice-7-6-5'>libreoffice-7-6-5</option>
<option value='libreoffice-7-6-6'>libreoffice-7-6-6</option>
<option value='libreoffice-7-6-7'>libreoffice-7-6-7</option>
<option value='master' selected='selected'>master</option>
<option value='ports/macosx10.5/master'>ports/macosx10.5/master</option>
<option value='private/Ashod/cd-5.3-3.2_import_unloaded'>private/Ashod/cd-5.3-3.2_import_unloaded</option>
<option value='private/Ashod/cd-5.3-3.2_import_unloaded_share_GfxLink'>private/Ashod/cd-5.3-3.2_import_unloaded_share_GfxLink</option>
<option value='private/Ashod/cd-5.3.3.2'>private/Ashod/cd-5.3.3.2</option>
<option value='private/Ashod/cp-5.0-preinit'>private/Ashod/cp-5.0-preinit</option>
<option value='private/Ashod/fast-calc-rendering'>private/Ashod/fast-calc-rendering</option>
<option value='private/Ashod/pdfium'>private/Ashod/pdfium</option>
<option value='private/Ashod/pdfium_on_master'>private/Ashod/pdfium_on_master</option>
<option value='private/Ashod/pdfium_on_master_fixed'>private/Ashod/pdfium_on_master_fixed</option>
<option value='private/EL-SHREIF/ui_logger'>private/EL-SHREIF/ui_logger</option>
<option value='private/Minion3665/swf-export'>private/Minion3665/swf-export</option>
<option value='private/Rosemary/change-tracking'>private/Rosemary/change-tracking</option>
<option value='private/Sweetshark/killswclient'>private/Sweetshark/killswclient</option>
<option value='private/Sweetshark/lessdepend'>private/Sweetshark/lessdepend</option>
<option value='private/Sweetshark/multilistenerfix'>private/Sweetshark/multilistenerfix</option>
<option value='private/ajrhunt/c4'>private/ajrhunt/c4</option>
<option value='private/ajrhunt/cunit'>private/ajrhunt/cunit</option>
<option value='private/ajrhunt/cunitdemo'>private/ajrhunt/cunitdemo</option>
<option value='private/ajrhunt/firebird-improvement'>private/ajrhunt/firebird-improvement</option>
<option value='private/bansan/chardraw'>private/bansan/chardraw</option>
<option value='private/bubli/textboxchaining'>private/bubli/textboxchaining</option>
<option value='private/hcvcastro/preinit'>private/hcvcastro/preinit</option>
<option value='private/hcvcastro/undo-row-comment'>private/hcvcastro/undo-row-comment</option>
<option value='private/jmux/armin-strip-before-squash'>private/jmux/armin-strip-before-squash</option>
<option value='private/jmux/broken-static-win'>private/jmux/broken-static-win</option>
<option value='private/jmux/current-reorga'>private/jmux/current-reorga</option>
<option value='private/jmux/meson'>private/jmux/meson</option>
<option value='private/jmux/meson-gsoc-2021'>private/jmux/meson-gsoc-2021</option>
<option value='private/jmux/oss-fuzz'>private/jmux/oss-fuzz</option>
<option value='private/jmux/oss-fuzz-wip'>private/jmux/oss-fuzz-wip</option>
<option value='private/jmux/scheduler-fixes'>private/jmux/scheduler-fixes</option>
<option value='private/jmux/shape.odt'>private/jmux/shape.odt</option>
<option value='private/jmux/wasm-for-master'>private/jmux/wasm-for-master</option>
<option value='private/jmux/wasm-tmp'>private/jmux/wasm-tmp</option>
<option value='private/jmux/wasm_for_master_catchall'>private/jmux/wasm_for_master_catchall</option>
<option value='private/jmux/win-arm64'>private/jmux/win-arm64</option>
<option value='private/jmux/win-test-nohang'>private/jmux/win-test-nohang</option>
<option value='private/juergen/Tests'>private/juergen/Tests</option>
<option value='private/juergen/check-cjk'>private/juergen/check-cjk</option>
<option value='private/kendy/condformat-api'>private/kendy/condformat-api</option>
<option value='private/kendy/condformat-fdo82014'>private/kendy/condformat-fdo82014</option>
<option value='private/kendy/mailmerge-04'>private/kendy/mailmerge-04</option>
<option value='private/kendy/mailmerge-05'>private/kendy/mailmerge-05</option>
<option value='private/kendy/swinterpreter'>private/kendy/swinterpreter</option>
<option value='private/kendy/testcl'>private/kendy/testcl</option>
<option value='private/khaledhosny/color-fonts'>private/khaledhosny/color-fonts</option>
<option value='private/khaledhosny/vcl-cleanup-font'>private/khaledhosny/vcl-cleanup-font</option>
<option value='private/kohei/chart-bugs'>private/kohei/chart-bugs</option>
<option value='private/kohei/find-replace-all-perf'>private/kohei/find-replace-all-perf</option>
<option value='private/kohei/headless-perf'>private/kohei/headless-perf</option>
<option value='private/kohei/if-or-not-if-jump'>private/kohei/if-or-not-if-jump</option>
<option value='private/kohei/sort-ref-update'>private/kohei/sort-ref-update</option>
<option value='private/lfrb/opengl-vcl'>private/lfrb/opengl-vcl</option>
<option value='private/lgodard/calc_notes_import_export'>private/lgodard/calc_notes_import_export</option>
<option value='private/lgodard/tdf#117202'>private/lgodard/tdf#117202</option>
<option value='private/llunak/mailmerge'>private/llunak/mailmerge</option>
<option value='private/llunak/mailmerge_01'>private/llunak/mailmerge_01</option>
<option value='private/llunak/mailmerge_02'>private/llunak/mailmerge_02</option>
<option value='private/llunak/mailmerge_03'>private/llunak/mailmerge_03</option>
<option value='private/llunak/munich_12587'>private/llunak/munich_12587</option>
<option value='private/llunak/skia'>private/llunak/skia</option>
<option value='private/lmamane/basetest'>private/lmamane/basetest</option>
<option value='private/lmamane/for-julien2412'>private/lmamane/for-julien2412</option>
<option value='private/lmamane/for-julien2412-master'>private/lmamane/for-julien2412-master</option>
<option value='private/lmamane/tdf110997'>private/lmamane/tdf110997</option>
<option value='private/lmamane/timedate-controls-nanosecond'>private/lmamane/timedate-controls-nanosecond</option>
<option value='private/lmamane/validation'>private/lmamane/validation</option>
<option value='private/mcecchetti/23H1/a11y/paragraph'>private/mcecchetti/23H1/a11y/paragraph</option>
<option value='private/mcecchetti/accessibility/paragraph'>private/mcecchetti/accessibility/paragraph</option>
<option value='private/mcecchetti/amd/pdf-export-jpeg'>private/mcecchetti/amd/pdf-export-jpeg</option>
<option value='private/mcecchetti/bitmapcrc64'>private/mcecchetti/bitmapcrc64</option>
<option value='private/mcecchetti/bitmapcrc64-5-0'>private/mcecchetti/bitmapcrc64-5-0</option>
<option value='private/mcecchetti/calc-perf-unit-test'>private/mcecchetti/calc-perf-unit-test</option>
<option value='private/mcecchetti/calc-unit-test'>private/mcecchetti/calc-unit-test</option>
<option value='private/mcecchetti/gl-program-binary'>private/mcecchetti/gl-program-binary</option>
<option value='private/mert/wip_deepl'>private/mert/wip_deepl</option>
<option value='private/mikekaganski/multicolumn'>private/mikekaganski/multicolumn</option>
<option value='private/mmeeks/aafixes44'>private/mmeeks/aafixes44</option>
<option value='private/mmeeks/backports'>private/mmeeks/backports</option>
<option value='private/mmeeks/binarydatacache'>private/mmeeks/binarydatacache</option>
<option value='private/mmeeks/bitmapcrc64'>private/mmeeks/bitmapcrc64</option>
<option value='private/mmeeks/copy-paste'>private/mmeeks/copy-paste</option>
<option value='private/mmeeks/copypaste'>private/mmeeks/copypaste</option>
<option value='private/mmeeks/cp-6.2-bits'>private/mmeeks/cp-6.2-bits</option>
<option value='private/mmeeks/cp64merge'>private/mmeeks/cp64merge</option>
<option value='private/mmeeks/currency-dropdown'>private/mmeeks/currency-dropdown</option>
<option value='private/mmeeks/foo'>private/mmeeks/foo</option>
<option value='private/mmeeks/formula-iterator'>private/mmeeks/formula-iterator</option>
<option value='private/mmeeks/gldebug'>private/mmeeks/gldebug</option>
<option value='private/mmeeks/hidpi-bits'>private/mmeeks/hidpi-bits</option>
<option value='private/mmeeks/icontest'>private/mmeeks/icontest</option>
<option value='private/mmeeks/opengl-backbuffer'>private/mmeeks/opengl-backbuffer</option>
<option value='private/mmeeks/opengl-backbuffer2'>private/mmeeks/opengl-backbuffer2</option>
<option value='private/mmeeks/sandbox'>private/mmeeks/sandbox</option>
<option value='private/mmeeks/swapdatacontainer'>private/mmeeks/swapdatacontainer</option>
<option value='private/mmeeks/vcl-opengl3'>private/mmeeks/vcl-opengl3</option>
<option value='private/moggi/fix-opengl-context-problems'>private/moggi/fix-opengl-context-problems</option>
<option value='private/moggi/improved-dxf-xls-export'>private/moggi/improved-dxf-xls-export</option>
<option value='private/moggi/opengl-4-4-build-test'>private/moggi/opengl-4-4-build-test</option>
<option value='private/moggi/opengl-preparation'>private/moggi/opengl-preparation</option>
<option value='private/moggi/opengl-vcl-win'>private/moggi/opengl-vcl-win</option>
<option value='private/moggi/orcus-improvements'>private/moggi/orcus-improvements</option>
<option value='private/moggi/track-win-dc'>private/moggi/track-win-dc</option>
<option value='private/moggi/ui-test'>private/moggi/ui-test</option>
<option value='private/moggi/vcl-opengl3'>private/moggi/vcl-opengl3</option>
<option value='private/mst/sw_fieldmarkhide'>private/mst/sw_fieldmarkhide</option>
<option value='private/mst/sw_redlinehide'>private/mst/sw_redlinehide</option>
<option value='private/mst/sw_redlinehide_2'>private/mst/sw_redlinehide_2</option>
<option value='private/mst/sw_redlinehide_3'>private/mst/sw_redlinehide_3</option>
<option value='private/mst/sw_redlinehide_4a'>private/mst/sw_redlinehide_4a</option>
<option value='private/mst/sw_redlinehide_4b'>private/mst/sw_redlinehide_4b</option>
<option value='private/pranavk/modernize_gtktiledviewer'>private/pranavk/modernize_gtktiledviewer</option>
<option value='private/quwex/gsoc-box2d-experimental'>private/quwex/gsoc-box2d-experimental</option>
<option value='private/quwex/notespane-search'>private/quwex/notespane-search</option>
<option value='private/quwex/notespaneflat'>private/quwex/notespaneflat</option>
<option value='private/quwex/notespanesquashed'>private/quwex/notespanesquashed</option>
<option value='private/quwex/tdf59323'>private/quwex/tdf59323</option>
<option value='private/s.mehrbrodt/colorpicker-backport'>private/s.mehrbrodt/colorpicker-backport</option>
<option value='private/sweetshark/swdepend'>private/sweetshark/swdepend</option>
<option value='private/tbsdy/clipping'>private/tbsdy/clipping</option>
<option value='private/tbsdy/drawserverfontlayout'>private/tbsdy/drawserverfontlayout</option>
<option value='private/tbsdy/emf'>private/tbsdy/emf</option>
<option value='private/tbsdy/osl_getAllEnvironment'>private/tbsdy/osl_getAllEnvironment</option>
<option value='private/tbsdy/outdev'>private/tbsdy/outdev</option>
<option value='private/tbsdy/printinfomgr'>private/tbsdy/printinfomgr</option>
<option value='private/tbsdy/workbench'>private/tbsdy/workbench</option>
<option value='private/thb/libo-6-1+backports'>private/thb/libo-6-1+backports</option>
<option value='private/thb/libreoffice-5-2+backports'>private/thb/libreoffice-5-2+backports</option>
<option value='private/thb/sw_redlinehide-6-1'>private/thb/sw_redlinehide-6-1</option>
<option value='private/thb/tdf149754'>private/thb/tdf149754</option>
<option value='private/thb/wasm-upstreaming'>private/thb/wasm-upstreaming</option>
<option value='private/timar/cp-6.2-centos7'>private/timar/cp-6.2-centos7</option>
<option value='private/timar/fontconfigcrash'>private/timar/fontconfigcrash</option>
<option value='private/timar/pythonupgrademsp'>private/timar/pythonupgrademsp</option>
<option value='private/tml/Use-the-iOS-French-and-Italian-dictionaries-for-othe'>private/tml/Use-the-iOS-French-and-Italian-dictionaries-for-othe</option>
<option value='private/tml/android-use-bionic-linker-copy'>private/tml/android-use-bionic-linker-copy</option>
<option value='private/tml/android-use-faulty.lib'>private/tml/android-use-faulty.lib</option>
<option value='private/tml/cp-6-4-28-1'>private/tml/cp-6-4-28-1</option>
<option value='private/tml/fixwintext'>private/tml/fixwintext</option>
<option value='private/tml/iculess'>private/tml/iculess</option>
<option value='private/tml/lov-6.1.5.2'>private/tml/lov-6.1.5.2</option>
<option value='private/tml/lov-6.2.1'>private/tml/lov-6.2.1</option>
<option value='private/tml/lov-7.0.3.3'>private/tml/lov-7.0.3.3</option>
<option value='private/tml/lov-7.0.4'>private/tml/lov-7.0.4</option>
<option value='private/tml/lov-7.1.2'>private/tml/lov-7.1.2</option>
<option value='private/tml/opencl-default-1'>private/tml/opencl-default-1</option>
<option value='private/tvajngerl/staging'>private/tvajngerl/staging</option>
<option value='ref/for/distro/collabora/cp-6.2'>ref/for/distro/collabora/cp-6.2</option>
</select> <input type='submit' value='switch'/></form></td></tr>
<tr><td class='sub'>LibreOffice 核心代码仓库</td><td class='sub right'>文档基金会</td></tr></table>
<table class='tabs'><tr><td>
<a href='/cgit/lo/core/'>summary</a><a href='/cgit/lo/core/refs/?id=8c8e4ae16472a1a234b02144bb075dc179dfd6df'>refs</a><a class='active' href='/cgit/lo/core/log/i18npool/Library_index_data.mk'>log</a><a href='/cgit/lo/core/tree/i18npool/Library_index_data.mk?id=8c8e4ae16472a1a234b02144bb075dc179dfd6df'>tree</a><a href='/cgit/lo/core/commit/i18npool/Library_index_data.mk?id=8c8e4ae16472a1a234b02144bb075dc179dfd6df'>commit</a><a href='/cgit/lo/core/diff/i18npool/Library_index_data.mk?id=8c8e4ae16472a1a234b02144bb075dc179dfd6df'>diff</a></td><td class='form'><form class='right' method='get' action='/cgit/lo/core/log/i18npool/Library_index_data.mk'>
<input type='hidden' name='id' value='8c8e4ae16472a1a234b02144bb075dc179dfd6df'/><select name='qt'>
<option value='grep'>log msg</option>
<option value='author'>author</option>
<option value='committer'>committer</option>
<option value='range'>range</option>
</select>
<input class='txt' type='search' size='10' name='q' value=''/>
<input type='submit' value='search'/>
</form>
</td></tr></table>
<div class='path'>path: <a href='/cgit/lo/core/log/?id=8c8e4ae16472a1a234b02144bb075dc179dfd6df'>root</a>/<a href='/cgit/lo/core/log/i18npool?id=8c8e4ae16472a1a234b02144bb075dc179dfd6df'>i18npool</a>/<a href='/cgit/lo/core/log/i18npool/Library_index_data.mk?id=8c8e4ae16472a1a234b02144bb075dc179dfd6df'>Library_index_data.mk</a></div><div class='content'><table class='list nowrap'><tr class='nohover'><th class='left'>Age</th><th class='left'>Commit message (<a href='/cgit/lo/core/log/i18npool/Library_index_data.mk?id=8c8e4ae16472a1a234b02144bb075dc179dfd6df&amp;showmsg=1'>Expand</a>)</th><th class='left'>Author</th></tr>