path: root/cui/source/options/optaboutconfig.cxx

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

#include <o3tl/safeint.hxx>
#include <o3tl/string_view.hxx>
#include "optaboutconfig.hxx"

#include <comphelper/processfactory.hxx>
#include <comphelper/sequence.hxx>
#include <com/sun/star/configuration/theDefaultProvider.hpp>
#include <com/sun/star/lang/XMultiServiceFactory.hpp>
#include <com/sun/star/beans/NamedValue.hpp>
#include <com/sun/star/beans/UnknownPropertyException.hpp>
#include <com/sun/star/beans/XPropertySetInfo.hpp>
#include <com/sun/star/container/XNameAccess.hpp>
#include <com/sun/star/container/XNameReplace.hpp>
#include <com/sun/star/container/XHierarchicalName.hpp>
#include <com/sun/star/uno/Reference.hxx>
#include <com/sun/star/uno/Type.hxx>
#include <com/sun/star/uno/TypeClass.hpp>
#include <com/sun/star/util/XChangesBatch.hpp>
#include <com/sun/star/util/SearchFlags.hpp>
#include <com/sun/star/util/SearchAlgorithms2.hpp>
#include <cppu/unotype.hxx>
#include <rtl/ustrbuf.hxx>
#include <unotools/textsearch.hxx>
#include <utility>
#include <vcl/event.hxx>
#include <sal/log.hxx>
#include <tools/diagnose_ex.h>

#include <algorithm>
#include <memory>
#include <vector>

using namespace ::com::sun::star;
using namespace com::sun::star::uno;
using namespace com::sun::star::container;

#define SHORT_LEN_LIMIT     7
#define LONG_LEN_LIMIT      11
#define HYPER_LEN_LIMIT     20

struct Prop_Impl
{
    OUString    Name;
    OUString    Property;
    Any         Value;

    Prop_Impl( OUString sName, OUString sProperty, Any aValue )
        : Name(std::move( sName ))
        , Property(std::move( sProperty ))
        , Value(std::move( aValue ))
    {}
};

struct UserData
{
    bool bIsPropertyPath;
    OUString sPropertyPath;
    int aLineage;
    Reference<XNameAccess> aXNameAccess;

    explicit UserData( OUString aPropertyPath )
        : bIsPropertyPath( true )
        , sPropertyPath(std::move(aPropertyPath))
        , aLineage(0)
    {}

    explicit UserData( Reference<XNameAccess> const & rXNameAccess, int rIndex )
        : bIsPropertyPath( false )
        , aLineage(rIndex)
        , aXNameAccess( rXNameAccess )
    {}
};

IMPL_LINK(CuiAboutConfigValueDialog, KeyInputHdl, const KeyEvent&, rKeyEvent, bool)
{
    bool bValid = false;
    bool bNonSpace = rKeyEvent.GetKeyCode().GetCode() != KEY_SPACE;
    if (m_bNumericOnly && bNonSpace )
    {
        const vcl::KeyCode& rKeyCode = rKeyEvent.GetKeyCode();
        sal_uInt16 nGroup = rKeyCode.GetGroup();
        sal_uInt16 nKey = rKeyCode.GetCode();

        switch ( nGroup ) {
            case KEYGROUP_NUM :
            case KEYGROUP_CURSOR :
            {
                bValid = true;
                break;
            }

            case KEYGROUP_MISC :
            {
                switch ( nKey ) {
                    case KEY_SUBTRACT :
                    case KEY_COMMA :
                    case KEY_POINT :
                    {
                        bValid = true;
                        break;
                    }

                    default :
                    {
                        if( nKey < KEY_ADD || nKey > KEY_EQUAL )
                            bValid = true;
                        break;
                    }
                }
                break;
            }

            default :
            {
                bValid = false;
                break;
            }
        }

        //Select all, Copy, Paste, Cut, Undo Keys
        if ( !bValid && ( rKeyCode.IsMod1() && (
             KEY_A == nKey || KEY_C == nKey || KEY_V == nKey || KEY_X == nKey || KEY_Z == nKey ) ) )
            bValid = true;
    }
    else
        bValid = true;

    //if value return true to claim that it has been handled
    return !bValid;
}

CuiAboutConfigTabPage::CuiAboutConfigTabPage(weld::Window* pParent)
    : GenericDialogController(pParent, "cui/ui/aboutconfigdialog.ui", "AboutConfig")
    , m_xResetBtn(m_xBuilder->weld_button("reset"))
    , m_xEditBtn(m_xBuilder->weld_button("edit"))
    , m_xSearchBtn(m_xBuilder->weld_button("searchButton"))
    , m_xSearchEdit(m_xBuilder->weld_entry("searchEntry"))
    , m_xPrefBox(m_xBuilder->weld_tree_view("preferences"))
    , m_xScratchIter(m_xPrefBox->make_iterator())
    , m_bSorted(false)
{
    m_xPrefBox->set_size_request(m_xPrefBox->get_approximate_digit_width() * 100,
                                 m_xPrefBox->get_height_rows(23));
    m_xPrefBox->connect_column_clicked(LINK(this, CuiAboutConfigTabPage, HeaderBarClick));

    m_xEditBtn->connect_clicked(LINK( this, CuiAboutConfigTabPage, StandardHdl_Impl));
    m_xResetBtn->connect_clicked(LINK( this, CuiAboutConfigTabPage, ResetBtnHdl_Impl));
    m_xPrefBox->connect_row_activated(LINK(this, CuiAboutConfigTabPage, DoubleClickHdl_Impl));
    m_xPrefBox->connect_expanding(LINK(this, CuiAboutConfigTabPage, ExpandingHdl_Impl));
    m_xSearchBtn->connect_clicked(LINK(this, CuiAboutConfigTabPage, SearchHdl_Impl));

    m_options.AlgorithmType2 = util::SearchAlgorithms2::ABSOLUTE;
    m_options.transliterateFlags |= TransliterationFlags::IGNORE_CASE;
    m_options.searchFlag |= (util::SearchFlags::REG_NOT_BEGINOFLINE |
                                        util::SearchFlags::REG_NOT_ENDOFLINE);

    float fWidth = m_xPrefBox->get_approximate_digit_width();
    std::vector<int> aWidths
    {
        o3tl::narrowing<int>(fWidth * 65),
        o3tl::narrowing<int>(fWidth * 20),
        o3tl::narrowing<int>(fWidth * 8)
    };
    m_xPrefBox->set_column_fixed_widths(aWidths);
}

IMPL_LINK(CuiAboutConfigTabPage, HeaderBarClick, int, nColumn, void)
{
    if (!m_bSorted)
    {
        m_xPrefBox->make_sorted();
        m_bSorted = true;
    }

    bool bSortAtoZ = m_xPrefBox->get_sort_order();

    //set new arrow positions in headerbar
    if (nColumn == m_xPrefBox->get_sort_column())
    {
        bSortAtoZ = !bSortAtoZ;
        m_xPrefBox->set_sort_order(bSortAtoZ);
    }
    else
    {
        int nOldSortColumn = m_xPrefBox->get_sort_column();
        if (nOldSortColumn != -1)
            m_xPrefBox->set_sort_indicator(TRISTATE_INDET, nOldSortColumn);
        m_xPrefBox->set_sort_column(nColumn);
    }

    if (nColumn != -1)
    {
        //sort lists
        m_xPrefBox->set_sort_indicator(bSortAtoZ ? TRISTATE_TRUE : TRISTATE_FALSE, nColumn);
    }
}

CuiAboutConfigTabPage::~CuiAboutConfigTabPage()
{
}

void CuiAboutConfigTabPage::InsertEntry(const OUString& rPropertyPath, const OUString& rProp, const OUString& rStatus,
                                        const OUString& rType, const OUString& rValue, const weld::TreeIter* pParentEntry,
                                        bool bInsertToPrefBox)
{
    m_vectorUserData.push_back(std::make_unique<UserData>(rPropertyPath));
    if (bInsertToPrefBox)
    {
        OUString sId(weld::toId(m_vectorUserData.back().get()));
        m_xPrefBox->insert(pParentEntry, -1, &rProp, &sId, nullptr, nullptr, false, m_xScratchIter.get());
        m_xPrefBox->set_text(*m_xScratchIter, rStatus, 1);
        m_xPrefBox->set_text(*m_xScratchIter, rType, 2);
        m_xPrefBox->set_text(*m_xScratchIter, rValue, 3);
    }
    else
    {
        m_prefBoxEntries.push_back({rProp, rStatus, rType, rValue, m_vectorUserData.back().get()});
    }
}

void CuiAboutConfigTabPage::Reset()
{
    weld::WaitObject aWait(m_xDialog.get());

    m_xPrefBox->clear();
    m_vectorOfModified.clear();
    if (m_bSorted)
    {
        m_xPrefBox->set_sort_indicator(TRISTATE_INDET, m_xPrefBox->get_sort_column());
        m_xPrefBox->make_unsorted();
        m_bSorted = false;
    }
    m_prefBoxEntries.clear();
    m_modifiedPrefBoxEntries.clear();

    m_xPrefBox->freeze();
    Reference< XNameAccess > xConfigAccess = getConfigAccess( "/", false );
    //Load all XNameAccess to m_prefBoxEntries
    FillItems( xConfigAccess, nullptr, 0, true );
    //Load xConfigAccess' children to m_prefBox
    FillItems( xConfigAccess );
    m_xPrefBox->thaw();
}

void CuiAboutConfigTabPage::FillItemSet()
{
    std::vector< std::shared_ptr< Prop_Impl > >::iterator pIter;
    for( pIter = m_vectorOfModified.begin() ; pIter != m_vectorOfModified.end(); ++pIter )
    {
        Reference< XNameAccess > xUpdateAccess = getConfigAccess( (*pIter)->Name , true );
        Reference< XNameReplace > xNameReplace( xUpdateAccess, UNO_QUERY_THROW );

        xNameReplace->replaceByName( (*pIter)->Property, (*pIter)->Value );

        Reference< util::XChangesBatch > xChangesBatch( xUpdateAccess, UNO_QUERY_THROW );
        xChangesBatch->commitChanges();
    }
}

void CuiAboutConfigTabPage::FillItems(const Reference< XNameAccess >& xNameAccess, const weld::TreeIter* pParentEntry,
                                      int lineage, bool bLoadAll)
{
    OUString sPath = Reference< XHierarchicalName >(
        xNameAccess, uno::UNO_QUERY_THROW )->getHierarchicalName();
    const uno::Sequence< OUString > seqItems = xNameAccess->getElementNames();
    for( const OUString& item : seqItems )
    {
        Any aNode = xNameAccess->getByName( item );

        bool bNotLeaf = false;

        Reference< XNameAccess > xNextNameAccess;
        try
        {
            xNextNameAccess.set(aNode, uno::UNO_QUERY);
            bNotLeaf = xNextNameAccess.is();
        }
        catch (const RuntimeException&)
        {
            TOOLS_WARN_EXCEPTION( "cui.options", "CuiAboutConfigTabPage");
        }

        if (bNotLeaf)
        {
            if(bLoadAll)
                FillItems(xNextNameAccess, nullptr, lineage + 1, true);
            else
            {
                // not leaf node
                m_vectorUserData.push_back(std::make_unique<UserData>(xNextNameAccess, lineage + 1));
                OUString sId(weld::toId(m_vectorUserData.back().get()));

                m_xPrefBox->insert(pParentEntry, -1, &item, &sId, nullptr, nullptr, true, m_xScratchIter.get());
                // Necessary, without this the selection line will be truncated.
                m_xPrefBox->set_text(*m_xScratchIter, "", 1);
                m_xPrefBox->set_text(*m_xScratchIter, "", 2);
                m_xPrefBox->set_text(*m_xScratchIter, "", 3);
            }
        }
        else
        {
            // leaf node
            OUString sPropertyName = item;
            auto it = std::find_if(m_modifiedPrefBoxEntries.begin(), m_modifiedPrefBoxEntries.end(),
              [&sPath, &sPropertyName](const prefBoxEntry& rEntry) -> bool
              {
                  return rEntry.pUserData->sPropertyPath == sPath
                      && rEntry.sStatus == sPropertyName;
              }
            );

            OUString sType = aNode.getValueTypeName();
            OUStringBuffer sValue;

            if (it != m_modifiedPrefBoxEntries.end())
                sValue = it->sValue;
            else
            {
                switch( aNode.getValueType().getTypeClass() )
                {
                case css::uno::TypeClass_VOID:
                    break;

                case css::uno::TypeClass_BOOLEAN:
                    sValue = OUString::boolean( aNode.get<bool>() );
                    break;

                case css::uno::TypeClass_SHORT:
                case css::uno::TypeClass_LONG:
                case css::uno::TypeClass_HYPER:
                    sValue = OUString::number( aNode.get<sal_Int64>() );
                    break;

                case css::uno::TypeClass_DOUBLE:
                    sValue = OUString::number( aNode.get<double>() );
                    break;

                case css::uno::TypeClass_STRING:
                    sValue = aNode.get<OUString>();
                    break;

                case css::uno::TypeClass_SEQUENCE:
                    if( sType == "[]boolean" )
                    {
                        uno::Sequence<sal_Bool> seq = aNode.get< uno::Sequence<sal_Bool> >();
                        for( sal_Int32 j = 0; j != seq.getLength(); ++j )
                        {
                            if( j != 0 )
                            {
                                sValue.append(",");
                            }
                            sValue.append(OUString::boolean( seq[j] ));
                        }
                    }
                    else if( sType == "[]byte" )
                    {
                        const uno::Sequence<sal_Int8> seq = aNode.get< uno::Sequence<sal_Int8> >();
                        for( sal_Int8 j : seq )
                        {
                            OUString s = OUString::number(
                                static_cast<sal_uInt8>(j), 16 );
                            if( s.getLength() == 1 )
                            {
                                sValue.append("0");
                            }
                            sValue.append(s.toAsciiUpperCase());
                        }
                    }
                    else if( sType == "[][]byte" )
                    {
                        const uno::Sequence< uno::Sequence<sal_Int8> > seq = aNode.get< uno::Sequence< uno::Sequence<sal_Int8> > >();
                        for( sal_Int32 j = 0; j != seq.getLength(); ++j )
                        {
                            if( j != 0 )
                            {
                                sValue.append(",");
                            }
                            for( sal_Int8 k : seq[j] )
                            {
                                OUString s = OUString::number(
                                    static_cast<sal_uInt8>(k), 16 );
                                if( s.getLength() == 1 )
                                {
                                    sValue.append("0");
                                }
                                sValue.append(s.toAsciiUpperCase());
                            }
                        }
                    }
                    else if( sType == "[]short" )
                    {
                        uno::Sequence<sal_Int16> seq = aNode.get< uno::Sequence<sal_Int16> >();
                        for( sal_Int32 j = 0; j != seq.getLength(); ++j )
                        {
                            if( j != 0 )
                            {
                                sValue.append(",");
                            }
                            sValue.append( static_cast<sal_Int32>(seq[j]) );
                        }
                    }
                    else if( sType == "[]long" )
                    {
                        uno::Sequence<sal_Int32> seq = aNode.get< uno::Sequence<sal_Int32> >();
                        for( sal_Int32 j = 0; j != seq.getLength(); ++j )
                        {
                            if( j != 0 )
                            {
                                sValue.append(",");
                            }
                            sValue.append( seq[j] );
                        }
                    }
                    else if( sType == "[]hyper" )
                    {
                        uno::Sequence<sal_Int64> seq = aNode.get< uno::Sequence<sal_Int64> >();
                        for( sal_Int32 j = 0; j != seq.getLength(); ++j )
                        {
                            if( j != 0 )
                            {
                                sValue.append(",");
                            }
                            sValue.append( seq[j] );
                        }
                    }
                    else if( sType == "[]double" )
                    {
                        uno::Sequence<double> seq = aNode.get< uno::Sequence<double> >();
                        for( sal_Int32 j = 0; j != seq.getLength(); ++j )
                        {
                            if( j != 0 )
                            {
                                sValue.append(",");
                            }
                            sValue.append( seq[j] );
                        }
                    }
                    else if( sType == "[]string" )
                    {
                        uno::Sequence<OUString> seq = aNode.get< uno::Sequence<OUString> >();
                        for( sal_Int32 j = 0; j != seq.getLength(); ++j )
                        {
                            if( j != 0 )
                            {
                                sValue.append(",");
                            }
                            sValue.append(seq[j]);
                        }
                    }
                    else
                    {
                        SAL_WARN(
                            "cui.options",
                            "path \"" << sPath << "\" member " << item
                                << " of unsupported type " << sType);
                    }
                    break;

                default:
                    SAL_WARN(
                        "cui.options",
                        "path \"" << sPath << "\" member " << item
                            << " of unsupported type " << sType);
                    break;
                }
            }

            //Short name
            int index = 0;
            for(int j = 1; j < lineage; ++j)
                index = sPath.indexOf("/", index + 1);

            InsertEntry(sPath, sPath.copy(index+1), item, sType, sValue.makeStringAndClear(), pParentEntry, !bLoadAll);
        }
    }
}

Reference< XNameAccess > CuiAboutConfigTabPage::getConfigAccess( const OUString& sNodePath, bool bUpdate )
{
    uno::Reference< uno::XComponentContext > xContext( ::comphelper::getProcessComponentContext() );

    uno::Reference< lang::XMultiServiceFactory > xConfigProvider(
                css::configuration::theDefaultProvider::get( xContext  ) );

    beans::NamedValue aProperty;
    aProperty.Name = "nodepath";
    aProperty.Value <<= sNodePath;

    uno::Sequence< uno::Any > aArgumentList{ uno::Any(aProperty) };

    OUString sAccessString;

    if( bUpdate )
        sAccessString = "com.sun.star.configuration.ConfigurationUpdateAccess";
    else
        sAccessString = "com.sun.star.configuration.ConfigurationAccess";

    uno::Reference< container::XNameAccess > xNameAccess(
                xConfigProvider->createInstanceWithArguments(
                    sAccessString, aArgumentList ),
                uno::UNO_QUERY_THROW );

    return xNameAccess;
}

void CuiAboutConfigTabPage::AddToModifiedVector( const std::shared_ptr< Prop_Impl >& rProp )
{
    bool isModifiedBefore = false;
    //Check if value modified before
    for(std::shared_ptr<Prop_Impl> & nInd : m_vectorOfModified)
    {
        if( rProp->Name == nInd->Name && rProp->Property == nInd->Property )
        {
            //property modified before. Assign reference to the modified value
            //do your changes on this object. They will be saved later.
            nInd = rProp;
            isModifiedBefore = true;
            break;
        }
    }

    if( !isModifiedBefore )
        m_vectorOfModified.push_back( rProp );
    //property is not modified before
}

std::vector< OUString > CuiAboutConfigTabPage::commaStringToSequence( std::u16string_view rCommaSepString )
{
    std::vector<OUString> tempVector;

    sal_Int32 index = 0;
    do
    {
        OUString word( o3tl::getToken(rCommaSepString, 0, u',', index) );
        word = word.trim();
        if( !word.isEmpty())
            tempVector.push_back(word);
    }while( index >= 0 );
    return tempVector;
}

CuiAboutConfigValueDialog::CuiAboutConfigValueDialog(weld::Window* pWindow,
                                                     const OUString& rValue,
                                                     int limit)
    : GenericDialogController(pWindow, "cui/ui/aboutconfigvaluedialog.ui", "AboutConfigValueDialog")
    , m_bNumericOnly(limit != 0)
    , m_xEDValue(m_xBuilder->weld_entry("valuebox"))
{
    if (limit)
        m_xEDValue->set_max_length(limit);
    m_xEDValue->set_text(rValue);
    m_xEDValue->connect_key_press(LINK(this, CuiAboutConfigValueDialog, KeyInputHdl));
}

CuiAboutConfigValueDialog::~CuiAboutConfigValueDialog()
{
}

IMPL_LINK_NOARG( CuiAboutConfigTabPage, ResetBtnHdl_Impl, weld::Button&, void )
{
    Reset();
}

IMPL_LINK_NOARG(CuiAboutConfigTabPage, DoubleClickHdl_Impl, weld::TreeView&, bool)
{
    StandardHdl_Impl(*m_xEditBtn);
    return true;
}

IMPL_LINK_NOARG( CuiAboutConfigTabPage, StandardHdl_Impl, weld::Button&, void )
{
    if (!m_xPrefBox->get_selected(m_xScratchIter.get()))
        return;

    UserData *pUserData = weld::fromId<UserData*>(m_xPrefBox->get_id(*m_xScratchIter));
    if (!(pUserData && pUserData->bIsPropertyPath))
        return;

    //if selection is a node
    OUString sPropertyName = m_xPrefBox->get_text(*m_xScratchIter, 1);
    OUString sPropertyType = m_xPrefBox->get_text(*m_xScratchIter, 2);
    OUString sPropertyValue = m_xPrefBox->get_text(*m_xScratchIter, 3);

    // If the configuration property has a nil value, determine its static type:
    if (sPropertyType == "void")
    {
        css::uno::Reference<css::beans::XPropertySetInfo> info(
            CuiAboutConfigTabPage::getConfigAccess(pUserData->sPropertyPath, false),
            css::uno::UNO_QUERY_THROW);
        css::uno::Type t;
        try {
            t = info->getPropertyByName(sPropertyName).Type;
        } catch (css::beans::UnknownPropertyException &) {
            TOOLS_WARN_EXCEPTION("cui.options", pUserData->sPropertyPath << " " << sPropertyName);
        }
        // If the configuration property is of type any (or an UnknownPropertyException was caught
        // above), stick to "void" for now (ideally, properties of type any would allow setting
        // values of arbitrary type, regardless of their current value, in this dialog anyway):
        if (t != cppu::UnoType<void>::get()) {
            sPropertyType = t.getTypeName();
            switch (t.getTypeClass()) {
            case css::uno::TypeClass_BOOLEAN:
                sPropertyValue = "false";
                break;
            case css::uno::TypeClass_SHORT:
            case css::uno::TypeClass_LONG:
            case css::uno::TypeClass_HYPER:
            case css::uno::TypeClass_DOUBLE:
                sPropertyValue = "0";
                break;
            default:
                break;
            }
        }
    }

    auto pProperty  = std::make_shared<Prop_Impl>( pUserData->sPropertyPath, sPropertyName, Any( sPropertyValue ) );
    bool bSaveChanges = false;

    bool bOpenDialog = true;
    OUString sDialogValue;

    if( sPropertyType == "boolean" )
    {
        bool bValue;
        if( sPropertyValue == "true" )
        {
            sDialogValue = "false";
            bValue = false;
        }
        else
        {
            sDialogValue = "true";
            bValue = true;
        }

        pProperty->Value <<= bValue;
        bOpenDialog = false;
        bSaveChanges = true;
    }
    else if ( sPropertyType == "void" )
    {
        bOpenDialog = false;
    }
    else
    {
        sDialogValue = sPropertyValue;
        bOpenDialog = true;
    }

    try
    {
        if( bOpenDialog )
        {
            //Cosmetic length limit for integer values.
            int limit=0;
            if( sPropertyType == "short" )
                limit = SHORT_LEN_LIMIT;
            else if( sPropertyType == "long" )
                limit = LONG_LEN_LIMIT;
            else if( sPropertyType == "hyper" )
                limit = HYPER_LEN_LIMIT;

            CuiAboutConfigValueDialog aValueDialog(m_xDialog.get(), sDialogValue, limit);

            if (aValueDialog.run() == RET_OK )
            {
                OUString sNewValue = aValueDialog.getValue();
                bSaveChanges = true;
                if ( sPropertyType == "short")
                {
                    sal_Int16 nShort;
                    sal_Int32 nNumb = sNewValue.toInt32();

                    //if the value is 0 and length is not 1, there is something wrong
                    if( ( nNumb==0 && sNewValue.getLength()!=1 ) || nNumb > SAL_MAX_INT16 || nNumb < SAL_MIN_INT16)
                        throw uno::Exception("out of range short", nullptr);
                    nShort = static_cast<sal_Int16>(nNumb);
                    pProperty->Value <<= nShort;
                }
                else if( sPropertyType == "long" )
                {
                    sal_Int32 nLong = sNewValue.toInt32();
                    if( nLong==0 && sNewValue.getLength()!=1)
                        throw uno::Exception("out of range long", nullptr);
                    pProperty->Value <<= nLong;
                }
                else if( sPropertyType == "hyper")
                {
                    sal_Int64 nHyper = sNewValue.toInt64();
                    if( nHyper==0 && sNewValue.getLength()!=1)
                        throw uno::Exception("out of range hyper", nullptr);
                    pProperty->Value <<= nHyper;
                }
                else if( sPropertyType == "double")
                {
                    double nDoub = sNewValue.toDouble();
                    if( nDoub ==0 && sNewValue.getLength()!=1)
                        throw uno::Exception("out of range double", nullptr);
                    pProperty->Value <<= nDoub;
                }
                else if( sPropertyType == "float")
                {
                    float nFloat = sNewValue.toFloat();
                    if( nFloat ==0 && sNewValue.getLength()!=1)
                        throw uno::Exception("out of range float", nullptr);
                    pProperty->Value <<= nFloat;
                }
                else if( sPropertyType == "string" )
                {
                    pProperty->Value <<= sNewValue;
                }
                else if( sPropertyType == "[]short" )
                {
                    //create string sequence from comma separated string
                    //uno::Sequence< OUString > seqStr;
                    std::vector< OUString > seqStr = commaStringToSequence( sNewValue );

                    //create appropriate sequence with same size as string sequence
                    uno::Sequence< sal_Int16 > seqShort( seqStr.size() );
                    //convert all strings to appropriate type
                    std::transform(seqStr.begin(), seqStr.end(), seqShort.getArray(),
                                   [](const auto& str)
                                   { return static_cast<sal_Int16>(str.toInt32()); });
                    pProperty->Value <<= seqShort;
                }
                else if( sPropertyType == "[]long" )
                {
                    std::vector< OUString > seqStrLong = commaStringToSequence( sNewValue );

                    uno::Sequence< sal_Int32 > seqLong( seqStrLong.size() );
                    std::transform(seqStrLong.begin(), seqStrLong.end(), seqLong.getArray(),
                        [](const auto& str) { return str.toInt32(); });
                    pProperty->Value <<= seqLong;
                }
                else if( sPropertyType == "[]hyper" )
                {
                    std::vector< OUString > seqStrHyper = commaStringToSequence( sNewValue );
                    uno::Sequence< sal_Int64 > seqHyper( seqStrHyper.size() );
                    std::transform(seqStrHyper.begin(), seqStrHyper.end(), seqHyper.getArray(),
                        [](const auto& str) { return str.toInt64(); });
                    pProperty->Value <<= seqHyper;
                }
                else if( sPropertyType == "[]double" )
                {
                    std::vector< OUString > seqStrDoub = commaStringToSequence( sNewValue );
                    uno::Sequence< double > seqDoub( seqStrDoub.size() );
                    std::transform(seqStrDoub.begin(), seqStrDoub.end(), seqDoub.getArray(),
                        [](const auto& str) { return str.toDouble(); });
                    pProperty->Value <<= seqDoub;
                }
                else if( sPropertyType == "[]float" )
                {
                    std::vector< OUString > seqStrFloat = commaStringToSequence( sNewValue );
                    uno::Sequence< sal_Int16 > seqFloat( seqStrFloat.size() );
                    std::transform(seqStrFloat.begin(), seqStrFloat.end(), seqFloat.getArray(),
                        [](const auto& str) { return str.toFloat(); });
                    pProperty->Value <<= seqFloat;
                }
                else if( sPropertyType == "[]string" )
                {
                    pProperty->Value <<= comphelper::containerToSequence( commaStringToSequence( sNewValue ));
                }
                else //unknown
                    throw uno::Exception("unknown property type " + sPropertyType, nullptr);

                sDialogValue = sNewValue;
            }
        }

        if(bSaveChanges)
        {
            AddToModifiedVector( pProperty );

            //update listbox value.
            m_xPrefBox->set_text(*m_xScratchIter, sPropertyType, 2);
            m_xPrefBox->set_text(*m_xScratchIter, sDialogValue, 3);
            //update m_prefBoxEntries
            auto it = std::find_if(m_prefBoxEntries.begin(), m_prefBoxEntries.end(),
              [&pUserData, &sPropertyName](const prefBoxEntry& rEntry) -> bool
              {
                  return rEntry.pUserData->sPropertyPath == pUserData->sPropertyPath
                      && rEntry.sStatus == sPropertyName;
              }
            );
            if (it != m_prefBoxEntries.end())
            {
                it->sValue = sDialogValue;

                auto modifiedIt = std::find_if(
                            m_modifiedPrefBoxEntries.begin(), m_modifiedPrefBoxEntries.end(),
                            [&pUserData, &sPropertyName](const prefBoxEntry& rEntry) -> bool
                            {
                                return rEntry.pUserData->sPropertyPath == pUserData->sPropertyPath
                                    && rEntry.sStatus == sPropertyName;
                            }
                );

                if (modifiedIt != m_modifiedPrefBoxEntries.end())
                {
                    modifiedIt->sValue = sDialogValue;
                }
                else
                {
                    m_modifiedPrefBoxEntries.push_back(*it);
                }
            }
        }
    }
    catch( uno::Exception& )
    {
    }
}

IMPL_LINK_NOARG( CuiAboutConfigTabPage, SearchHdl_Impl, weld::Button&, void)
{
    weld::WaitObject aWait(m_xDialog.get());

    m_xPrefBox->hide();
    m_xPrefBox->clear();
    m_xPrefBox->freeze();

    if (m_bSorted)
        m_xPrefBox->make_unsorted();

    if (m_xSearchEdit->get_text().isEmpty())
    {
        m_xPrefBox->clear();
        Reference< XNameAccess > xConfigAccess = getConfigAccess( "/", false );
        FillItems( xConfigAccess );
    }
    else
    {
        m_options.searchString = m_xSearchEdit->get_text();
        utl::TextSearch textSearch( m_options );
        for (auto const& it : m_prefBoxEntries)
        {
            sal_Int32 endPos, startPos = 0;

            for(size_t i = 0; i < 5; ++i)
            {
                OUString scrTxt;

                if (i == 0)
                    scrTxt = it.pUserData->sPropertyPath;
                else if (i == 1)
                    scrTxt = it.sProp;
                else if (i == 2)
                    scrTxt = it.sStatus;
                else if (i == 3)
                    scrTxt = it.sType;
                else if (i == 4)
                    scrTxt = it.sValue;

                endPos = scrTxt.getLength();
                if (textSearch.SearchForward(scrTxt, &startPos, &endPos))
                {
                    InsertEntry(it);
                    break;
                }
            }
        }
    }

    m_xPrefBox->thaw();
    if (m_bSorted)
        m_xPrefBox->make_sorted();

    m_xPrefBox->all_foreach([this](weld::TreeIter& rEntry) {
        m_xPrefBox->expand_row(rEntry);
        return false;
    });
    m_xPrefBox->show();
}

void CuiAboutConfigTabPage::InsertEntry(const prefBoxEntry& rEntry)
{
    OUString sPathWithProperty = rEntry.pUserData->sPropertyPath;
    sal_Int32 index = sPathWithProperty.lastIndexOf(rEntry.sProp);
    OUString sPath = sPathWithProperty.copy(0, index);
    index = 0;
    std::unique_ptr<weld::TreeIter> xParentEntry(m_xPrefBox->make_iterator());
    std::unique_ptr<weld::TreeIter> xGrandParentEntry;

    do
    {
        int prevIndex = index;
        index = sPath.indexOf("/", index+1);
        // deal with no parent case (tdf#107811)
        if (index < 0)
        {
            OUString sId(weld::toId(rEntry.pUserData));
            m_xPrefBox->insert(nullptr, -1, &rEntry.sProp, &sId, nullptr, nullptr, false, m_xScratchIter.get());
            m_xPrefBox->set_text(*m_xScratchIter, rEntry.sStatus, 1);
            m_xPrefBox->set_text(*m_xScratchIter, rEntry.sType, 2);
            m_xPrefBox->set_text(*m_xScratchIter, rEntry.sValue, 3);
            return;
        }
        OUString sParentName = sPath.copy(prevIndex+1, index - prevIndex - 1);

        bool hasEntry = false;
        bool bStartOk;

        if (!xGrandParentEntry)
            bStartOk = m_xPrefBox->get_iter_first(*xParentEntry);
        else
        {
            m_xPrefBox->copy_iterator(*xGrandParentEntry, *xParentEntry);
            bStartOk = m_xPrefBox->iter_children(*xParentEntry);
        }

        if (bStartOk)
        {
            do
            {
                if (m_xPrefBox->get_text(*xParentEntry, 0) == sParentName)
                {
                    hasEntry = true;
                    break;
                }
            } while (m_xPrefBox->iter_next_sibling(*xParentEntry));
        }

        if (!hasEntry)
        {
            m_xPrefBox->insert(xGrandParentEntry.get(), -1, &sParentName, nullptr, nullptr, nullptr, false, xParentEntry.get());
            //It is needed, without this the selection line will be truncated.
            m_xPrefBox->set_text(*xParentEntry, "", 1);
            m_xPrefBox->set_text(*xParentEntry, "", 2);
            m_xPrefBox->set_text(*xParentEntry, "", 3);
        }

        xGrandParentEntry = m_xPrefBox->make_iterator(xParentEntry.get());
    } while(index < sPath.getLength() - 1);

    OUString sId(weld::toId(rEntry.pUserData));
    m_xPrefBox->insert(xParentEntry.get(), -1, &rEntry.sProp, &sId, nullptr, nullptr, false, m_xScratchIter.get());
    m_xPrefBox->set_text(*m_xScratchIter, rEntry.sStatus, 1);
    m_xPrefBox->set_text(*m_xScratchIter, rEntry.sType, 2);
    m_xPrefBox->set_text(*m_xScratchIter, rEntry.sValue, 3);
}

IMPL_LINK(CuiAboutConfigTabPage, ExpandingHdl_Impl, const weld::TreeIter&, rEntry, bool)
{
    if (m_xPrefBox->iter_has_child(rEntry))
        return true;
    UserData *pUserData = weld::fromId<UserData*>(m_xPrefBox->get_id(rEntry));
    if (pUserData && !pUserData->bIsPropertyPath)
    {
        assert(pUserData->aXNameAccess.is());
        FillItems(pUserData->aXNameAccess, &rEntry, pUserData->aLineage);
    }
    return true;
}

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