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

    #include <com/sun/star/beans/XPropertySet.hpp>
    #include <com/sun/star/sheet/FilterConnection.hpp>
    #include <com/sun/star/sheet/FilterOperator2.hpp>
    #include <com/sun/star/sheet/TableFilterField3.hpp>
    #include <com/sun/star/sheet/XDatabaseRange.hpp>
    #include <com/sun/star/sheet/XSheetFilterDescriptor3.hpp>
    #include <com/sun/star/table/TableOrientation.hpp>
    #include <com/sun/star/table/CellAddress.hpp>
    #include <rtl/ustrbuf.hxx>
    #include <osl/diagnose.h>
    #include <oox/helper/attributelist.hxx>
    #include <oox/helper/containerhelper.hxx>
    #include <oox/helper/propertyset.hxx>
    #include <oox/helper/binaryinputstream.hxx>
    #include <oox/token/namespaces.hxx>
    #include <oox/token/properties.hxx>
    #include <oox/token/tokens.hxx>
    #include <addressconverter.hxx>
    #include <defnamesbuffer.hxx>
    #include <biffhelper.hxx>

    namespace oox {
    namespace xls {

    using namespace ::com::sun::star::sheet;
    using namespace ::com::sun::star::table;
    using namespace ::com::sun::star::uno;

    namespace {

    const sal_uInt8 BIFF12_TOP10FILTER_TOP              = 0x01;
    const sal_uInt8 BIFF12_TOP10FILTER_PERCENT          = 0x02;

    const sal_uInt16 BIFF12_FILTERCOLUMN_HIDDENBUTTON   = 0x0001;
    const sal_uInt16 BIFF12_FILTERCOLUMN_SHOWBUTTON     = 0x0002;

    const sal_uInt8 BIFF_FILTER_DATATYPE_NONE           = 0;
    const sal_uInt8 BIFF_FILTER_DATATYPE_DOUBLE         = 4;
    const sal_uInt8 BIFF_FILTER_DATATYPE_STRING         = 6;
    const sal_uInt8 BIFF_FILTER_DATATYPE_BOOLEAN        = 8;
    const sal_uInt8 BIFF_FILTER_DATATYPE_EMPTY          = 12;
    const sal_uInt8 BIFF_FILTER_DATATYPE_NOTEMPTY       = 14;

    bool lclGetApiOperatorFromToken( sal_Int32& rnApiOperator, sal_Int32 nToken )
    {
        switch( nToken )
        {
            case XML_lessThan:              rnApiOperator = FilterOperator2::NOT_EQUAL;     return true;
            case XML_equal:                 rnApiOperator = FilterOperator2::EQUAL;         return true;
            case XML_lessThanOrEqual:       rnApiOperator = FilterOperator2::LESS_EQUAL;    return true;
            case XML_greaterThan:           rnApiOperator = FilterOperator2::GREATER;       return true;
            case XML_notEqual:              rnApiOperator = FilterOperator2::NOT_EQUAL;     return true;
            case XML_greaterThanOrEqual:    rnApiOperator = FilterOperator2::GREATER_EQUAL; return true;
        }
        return false;
    }

    /** Removes leading asterisk characters from the passed string.
        @return  True = at least one asterisk character has been removed. */
    bool lclTrimLeadingAsterisks( OUString& rValue )
    {
        sal_Int32 nLength = rValue.getLength();
        sal_Int32 nPos = 0;
        while( (nPos < nLength) && (rValue[ nPos ] == '*') )
            ++nPos;
        if( nPos > 0 )
        {
            rValue = rValue.copy( nPos );
            return true;
        }
        return false;
    }

    /** Removes trailing asterisk characters from the passed string.
        @return  True = at least one asterisk character has been removed. */
    bool lclTrimTrailingAsterisks( OUString& rValue )
    {
        sal_Int32 nLength = rValue.getLength();
        sal_Int32 nPos = nLength;
        while( (nPos > 0) && (rValue[ nPos - 1 ] == '*') )
            --nPos;
        if( nPos < nLength )
        {
            rValue = rValue.copy( 0, nPos );
            return true;
        }
        return false;
    }

    /** Converts wildcard characters '*' and '?' to regular expressions and quotes
        RE meta characters.
        @return  True = passed string has been changed (RE needs to be enabled). */
    bool lclConvertWildcardsToRegExp( OUString& rValue )
    {
        // check existence of the wildcard characters '*' and '?'
        if( !rValue.isEmpty() && ((rValue.indexOf( '*' ) >= 0) || (rValue.indexOf( '?' ) >= 0)) )
        {
            OUStringBuffer aBuffer;
            aBuffer.ensureCapacity( rValue.getLength() + 5 );
            const sal_Unicode* pcChar = rValue.getStr();
            const sal_Unicode* pcEnd = pcChar + rValue.getLength();
            for( ; pcChar < pcEnd; ++pcChar )
            {
                switch( *pcChar )
                {
                    case '?':
                        aBuffer.append( '.' );
                    break;
                    case '*':
                        aBuffer.append( '.' ).append( '*' );
                    break;
                    case '\\': case '.': case '|': case '(': case ')': case '^': case '$':
                        // quote RE meta characters
                        aBuffer.append( '\\' ).append( *pcChar );
                    break;
                    default:
                        aBuffer.append( *pcChar );
                }
            }
            rValue = aBuffer.makeStringAndClear();
            return true;
        }
        return false;
    }

    } // namespace

    ApiFilterSettings::ApiFilterSettings()
    {
    }

    void ApiFilterSettings::appendField( bool bAnd, sal_Int32 nOperator, double fValue )
    {
        maFilterFields.emplace_back();
        TableFilterField3& rFilterField = maFilterFields.back();
        rFilterField.Connection = bAnd ? FilterConnection_AND : FilterConnection_OR;
        rFilterField.Operator = nOperator;
        rFilterField.Values.realloc(1);
        rFilterField.Values[0].IsNumeric = true;
        rFilterField.Values[0].NumericValue = fValue;
    }

    void ApiFilterSettings::appendField( bool bAnd, sal_Int32 nOperator, const OUString& rValue )
    {
        maFilterFields.emplace_back();
        TableFilterField3& rFilterField = maFilterFields.back();
        rFilterField.Connection = bAnd ? FilterConnection_AND : FilterConnection_OR;
        rFilterField.Operator = nOperator;
        rFilterField.Values.realloc(1);
        rFilterField.Values[0].IsNumeric = false;
        rFilterField.Values[0].StringValue = rValue;
    }

    void ApiFilterSettings::appendField( bool bAnd, const std::vector<OUString>& rValues )
    {
        maFilterFields.emplace_back();
        TableFilterField3& rFilterField = maFilterFields.back();
        rFilterField.Connection = bAnd ? FilterConnection_AND : FilterConnection_OR;
        rFilterField.Operator = FilterOperator2::EQUAL;
        size_t n = rValues.size();
        rFilterField.Values.realloc(n);
        for (size_t i = 0; i < n; ++i)
        {
            rFilterField.Values[i].IsNumeric = false;
            rFilterField.Values[i].StringValue = rValues[i];
        }
    }

    FilterSettingsBase::FilterSettingsBase( const WorkbookHelper& rHelper ) :
        WorkbookHelper( rHelper )
    {
    }

    void FilterSettingsBase::importAttribs( sal_Int32 /*nElement*/, const AttributeList& /*rAttribs*/ )
    {
    }

    void FilterSettingsBase::importRecord( sal_Int32 /*nRecId*/, SequenceInputStream& /*rStrm*/ )
    {
    }

    ApiFilterSettings FilterSettingsBase::finalizeImport( sal_Int32 /*nMaxCount*/ )
    {
        return ApiFilterSettings();
    }

    DiscreteFilter::DiscreteFilter( const WorkbookHelper& rHelper ) :
        FilterSettingsBase( rHelper ),
        mnCalendarType( XML_none ),
        mbShowBlank( false )
    {
    }

    void DiscreteFilter::importAttribs( sal_Int32 nElement, const AttributeList& rAttribs )
    {
        switch( nElement )
        {
            case XLS_TOKEN( filters ):
                mnCalendarType = rAttribs.getToken( XML_calendarType, XML_none );
                mbShowBlank = rAttribs.getBool( XML_blank, false );
            break;

            case XLS_TOKEN( filter ):
            {
                OUString aValue = rAttribs.getXString( XML_val, OUString() );
                if( !aValue.isEmpty() )
                    maValues.push_back( aValue );
            }
            break;
        }
    }

    void DiscreteFilter::importRecord( sal_Int32 nRecId, SequenceInputStream& rStrm )
    {
        switch( nRecId )
        {
            case BIFF12_ID_DISCRETEFILTERS:
            {
                sal_Int32 nShowBlank, nCalendarType;
                nShowBlank = rStrm.readInt32();
                nCalendarType = rStrm.readInt32();

                static const sal_Int32 spnCalendarTypes[] = {
                    XML_none, XML_gregorian, XML_gregorianUs, XML_japan, XML_taiwan, XML_korea, XML_hijri, XML_thai, XML_hebrew,
                    XML_gregorianMeFrench, XML_gregorianArabic, XML_gregorianXlitEnglish, XML_gregorianXlitFrench };
                mnCalendarType = STATIC_ARRAY_SELECT( spnCalendarTypes, nCalendarType, XML_none );
                mbShowBlank = nShowBlank != 0;
            }
            break;

            case BIFF12_ID_DISCRETEFILTER:
            {
                OUString aValue = BiffHelper::readString( rStrm );
                if( !aValue.isEmpty() )
                    maValues.push_back( aValue );
            }
            break;
        }
    }

    ApiFilterSettings DiscreteFilter::finalizeImport( sal_Int32 nMaxCount )
    {
        ApiFilterSettings aSettings;
        if( static_cast< sal_Int32 >( maValues.size() ) <= nMaxCount )
        {
            aSettings.maFilterFields.reserve( maValues.size() );

            // insert all filter values
            aSettings.appendField( true, maValues );

            // extra field for 'show empty'
            if( mbShowBlank )
                aSettings.appendField( false, FilterOperator2::EMPTY, OUString() );

            /*  Require disabled regular expressions, filter entries may contain
                any RE meta characters. */
            if( !maValues.empty() )
                aSettings.mobNeedsRegExp = false;
        }
        return aSettings;
    }

    Top10Filter::Top10Filter( const WorkbookHelper& rHelper ) :
        FilterSettingsBase( rHelper ),
        mfValue( 0.0 ),
        mbTop( true ),
        mbPercent( false )
    {
    }

    void Top10Filter::importAttribs( sal_Int32 nElement, const AttributeList& rAttribs )
    {
        if( nElement == XLS_TOKEN( top10 ) )
        {
            mfValue = rAttribs.getDouble( XML_val, 0.0 );
            mbTop = rAttribs.getBool( XML_top, true );
            mbPercent = rAttribs.getBool( XML_percent, false );
        }
    }

    void Top10Filter::importRecord( sal_Int32 nRecId, SequenceInputStream& rStrm )
    {
        if( nRecId == BIFF12_ID_TOP10FILTER )
        {
            sal_uInt8 nFlags;
            nFlags = rStrm.readuChar();
            mfValue = rStrm.readDouble();
            mbTop = getFlag( nFlags, BIFF12_TOP10FILTER_TOP );
            mbPercent = getFlag( nFlags, BIFF12_TOP10FILTER_PERCENT );
        }
    }

    ApiFilterSettings Top10Filter::finalizeImport( sal_Int32 /*nMaxCount*/ )
    {
        sal_Int32 nOperator = mbTop ?
            (mbPercent ? FilterOperator2::TOP_PERCENT : FilterOperator2::TOP_VALUES) :
            (mbPercent ? FilterOperator2::BOTTOM_PERCENT : FilterOperator2::BOTTOM_VALUES);
        ApiFilterSettings aSettings;
        aSettings.appendField( true, nOperator, mfValue );
        return aSettings;
    }

    FilterCriterionModel::FilterCriterionModel() :
        mnOperator( XML_equal ),
        mnDataType( BIFF_FILTER_DATATYPE_NONE )
    {
    }

    void FilterCriterionModel::setBiffOperator( sal_uInt8 nOperator )
    {
        static const sal_Int32 spnOperators[] = { XML_TOKEN_INVALID,
            XML_lessThan, XML_equal, XML_lessThanOrEqual, XML_greaterThan, XML_notEqual, XML_greaterThanOrEqual };
        mnOperator = STATIC_ARRAY_SELECT( spnOperators, nOperator, XML_TOKEN_INVALID );
    }

    void FilterCriterionModel::readBiffData( SequenceInputStream& rStrm )
    {
        sal_uInt8 nOperator;
        mnDataType = rStrm.readuChar();
        nOperator = rStrm.readuChar();
        setBiffOperator( nOperator );

        switch( mnDataType )
        {
            case BIFF_FILTER_DATATYPE_DOUBLE:
                maValue <<= rStrm.readDouble();
            break;
            case BIFF_FILTER_DATATYPE_STRING:
            {
                rStrm.skip( 8 );
                OUString aValue = BiffHelper::readString( rStrm ).trim();
                if( !aValue.isEmpty() )
                    maValue <<= aValue;
            }
            break;
            case BIFF_FILTER_DATATYPE_BOOLEAN:
                maValue <<= (rStrm.readuInt8() != 0);
                rStrm.skip( 7 );
            break;
            case BIFF_FILTER_DATATYPE_EMPTY:
                rStrm.skip( 8 );
                if( mnOperator == XML_equal )
                    maValue <<= OUString();
            break;
            case BIFF_FILTER_DATATYPE_NOTEMPTY:
                rStrm.skip( 8 );
                if( mnOperator == XML_notEqual )
                    maValue <<= OUString();
            break;
            default:
                OSL_ENSURE( false, "FilterCriterionModel::readBiffData - unexpected data type" );
                rStrm.skip( 8 );
        }
    }

    CustomFilter::CustomFilter( const WorkbookHelper& rHelper ) :
        FilterSettingsBase( rHelper ),
        mbAnd( false )
    {
    }

    void CustomFilter::importAttribs( sal_Int32 nElement, const AttributeList& rAttribs )
    {
        switch( nElement )
        {
            case XLS_TOKEN( customFilters ):
                mbAnd = rAttribs.getBool( XML_and, false );
            break;

            case XLS_TOKEN( customFilter ):
            {
                FilterCriterionModel aCriterion;
                aCriterion.mnOperator = rAttribs.getToken( XML_operator, XML_equal );
                OUString aValue = rAttribs.getXString( XML_val, OUString() ).trim();
                if( (aCriterion.mnOperator == XML_equal) || (aCriterion.mnOperator == XML_notEqual) || (!aValue.isEmpty()) )
                    aCriterion.maValue <<= aValue;
                appendCriterion( aCriterion );
            }
            break;
        }
    }

    void CustomFilter::importRecord( sal_Int32 nRecId, SequenceInputStream& rStrm )
    {
        switch( nRecId )
        {
            case BIFF12_ID_CUSTOMFILTERS:
                mbAnd = rStrm.readInt32() == 0;
            break;

            case BIFF12_ID_CUSTOMFILTER:
            {
                FilterCriterionModel aCriterion;
                aCriterion.readBiffData( rStrm );
                appendCriterion( aCriterion );
            }
            break;
        }
    }

    ApiFilterSettings CustomFilter::finalizeImport( sal_Int32 /*nMaxCount*/ )
    {
        ApiFilterSettings aSettings;
        OSL_ENSURE( maCriteria.size() <= 2, "CustomFilter::finalizeImport - too many filter criteria" );
        for( FilterCriterionVector::iterator aIt = maCriteria.begin(), aEnd = maCriteria.end(); aIt != aEnd; ++aIt )
        {
            // first extract the filter operator
            sal_Int32 nOperator = 0;
            bool bValidOperator = lclGetApiOperatorFromToken( nOperator, aIt->mnOperator );
            if( bValidOperator )
            {
                if( aIt->maValue.has< OUString >() )
                {
                    // string argument
                    OUString aValue;
                    aIt->maValue >>= aValue;
                    // check for 'empty', 'contains', 'begins with', or 'ends with' text filters
                    bool bEqual = nOperator == FilterOperator2::EQUAL;
                    bool bNotEqual = nOperator == FilterOperator2::NOT_EQUAL;
                    if( bEqual || bNotEqual )
                    {
                        if( aValue.isEmpty() )
                        {
                            // empty comparison string: create empty/not empty filters
                            nOperator = bNotEqual ? FilterOperator2::NOT_EMPTY : FilterOperator2::EMPTY;
                        }
                        else
                        {
                            // compare to something: try to find begins/ends/contains
                            bool bHasLeadingAsterisk = lclTrimLeadingAsterisks( aValue );
                            bool bHasTrailingAsterisk = lclTrimTrailingAsterisks( aValue );
                            // just '***' matches everything, do not create a filter field
                            bValidOperator = !aValue.isEmpty();
                            if( bValidOperator )
                            {
                                if( bHasLeadingAsterisk && bHasTrailingAsterisk )
                                    nOperator = bNotEqual ? FilterOperator2::DOES_NOT_CONTAIN : FilterOperator2::CONTAINS;
                                else if( bHasLeadingAsterisk )
                                    nOperator = bNotEqual ? FilterOperator2::DOES_NOT_END_WITH : FilterOperator2::ENDS_WITH;
                                else if( bHasTrailingAsterisk )
                                    nOperator = bNotEqual ? FilterOperator2::DOES_NOT_BEGIN_WITH : FilterOperator2::BEGINS_WITH;
                                // else: no asterisks, stick to equal/not equal
                            }
                        }
                    }

                    if( bValidOperator )
                    {
                        // if wildcards are present, require RE mode, otherwise keep don't care state
                        if( lclConvertWildcardsToRegExp( aValue ) )
                            aSettings.mobNeedsRegExp = true;
                        // create a new UNO API filter field
                        aSettings.appendField( mbAnd, nOperator, aValue );
                    }
                }
                else if( aIt->maValue.has< double >() )
                {
                    // floating-point argument
                    double fValue = 0.0;
                    aIt->maValue >>= fValue;
                    aSettings.appendField( mbAnd, nOperator, fValue );
                }
            }
        }
        return aSettings;
    }

    void CustomFilter::appendCriterion( const FilterCriterionModel& rCriterion )
    {
        if( (rCriterion.mnOperator != XML_TOKEN_INVALID) && rCriterion.maValue.hasValue() )
            maCriteria.push_back( rCriterion );
    }

    FilterColumn::FilterColumn( const WorkbookHelper& rHelper ) :
        WorkbookHelper( rHelper ),
        mnColId( -1 ),
        mbHiddenButton( false ),
        mbShowButton( true )
    {
    }

    void FilterColumn::importFilterColumn( const AttributeList& rAttribs )
    {
        mnColId = rAttribs.getInteger( XML_colId, -1 );
        mbHiddenButton = rAttribs.getBool( XML_hiddenButton, false );
        mbShowButton = rAttribs.getBool( XML_showButton, true );
    }

    void FilterColumn::importFilterColumn( SequenceInputStream& rStrm )
    {
        sal_uInt16 nFlags;
        mnColId = rStrm.readInt32();
        nFlags = rStrm.readuInt16();
        mbHiddenButton = getFlag( nFlags, BIFF12_FILTERCOLUMN_HIDDENBUTTON );
        mbShowButton = getFlag( nFlags, BIFF12_FILTERCOLUMN_SHOWBUTTON );
    }

    ApiFilterSettings FilterColumn::finalizeImport( sal_Int32 nMaxCount )
    {
        ApiFilterSettings aSettings;
        if( (0 <= mnColId) && mxSettings.get() )
        {
            // filter settings object creates a sequence of filter fields
            aSettings = mxSettings->finalizeImport( nMaxCount );
            // add column index to all filter fields
            for( ApiFilterSettings::FilterFieldVector::iterator aIt = aSettings.maFilterFields.begin(), aEnd = aSettings.maFilterFields.end(); aIt != aEnd; ++aIt )
                aIt->Field = mnColId;
        }
        return aSettings;
    }

    AutoFilter::AutoFilter( const WorkbookHelper& rHelper ) :
        WorkbookHelper( rHelper )
    {
    }

    void AutoFilter::importAutoFilter( const AttributeList& rAttribs, sal_Int16 nSheet )
    {
        OUString aRangeStr = rAttribs.getString( XML_ref, OUString() );
        AddressConverter::convertToCellRangeUnchecked( maRange, aRangeStr, nSheet );
    }

    void AutoFilter::importAutoFilter( SequenceInputStream& rStrm, sal_Int16 nSheet )
    {
        BinRange aBinRange;
        rStrm >> aBinRange;
        AddressConverter::convertToCellRangeUnchecked( maRange, aBinRange, nSheet );
    }

    FilterColumn& AutoFilter::createFilterColumn()
    {
        FilterColumnVector::value_type xFilterColumn( new FilterColumn( *this ) );
        maFilterColumns.push_back( xFilterColumn );
        return *xFilterColumn;
    }

    void AutoFilter::finalizeImport( const Reference<XSheetFilterDescriptor3>& rxFilterDesc )
    {
        if( rxFilterDesc.is() )
        {
            // set some common properties for the auto filter range
            PropertySet aDescProps( rxFilterDesc );
            aDescProps.setProperty( PROP_IsCaseSensitive, false );
            aDescProps.setProperty( PROP_SkipDuplicates, false );
            aDescProps.setProperty( PROP_Orientation, TableOrientation_ROWS );
            aDescProps.setProperty( PROP_ContainsHeader, true );
            aDescProps.setProperty( PROP_CopyOutputData, false );

            // maximum number of UNO API filter fields
            sal_Int32 nMaxCount = 0;
            aDescProps.getProperty( nMaxCount, PROP_MaxFieldCount );
            OSL_ENSURE( nMaxCount > 0, "AutoFilter::finalizeImport - invalid maximum filter field count" );

            // resulting list of all UNO API filter fields
            ::std::vector<TableFilterField3> aFilterFields;

            // track if columns require to enable or disable regular expressions
            OptValue< bool > obNeedsRegExp;

            /*  Track whether the filter fields of the first filter column are
                connected with 'or'. In this case, other filter fields cannot be
                inserted without altering the result of the entire filter, due to
                Calc's precedence for the 'and' connection operator. Example:
                Excel's filter conditions 'A1 and (B1 or B2) and C1' where B1 and
                B2 belong to filter column B, will be evaluated by Calc as
                '(A1 and B1) or (B2 and C1)'. */
            bool bHasOrConnection = false;

            // process all filter column objects, exit when 'or' connection exists
            for( FilterColumnVector::iterator aIt = maFilterColumns.begin(), aEnd = maFilterColumns.end(); !bHasOrConnection && (aIt != aEnd); ++aIt )
            {
                // the filter settings object creates a list of filter fields
                ApiFilterSettings aSettings = (*aIt)->finalizeImport( nMaxCount );
                ApiFilterSettings::FilterFieldVector& rColumnFields = aSettings.maFilterFields;

                // new total number of filter fields
                sal_Int32 nNewCount = static_cast< sal_Int32 >( aFilterFields.size() + rColumnFields.size() );

                /*  Check whether mode for regular expressions is compatible with
                    the global mode in obNeedsRegExp. If either one is still in
                    don't-care state, all is fine. If both are set, they must be
                    equal. */
                bool bRegExpCompatible = !obNeedsRegExp || !aSettings.mobNeedsRegExp || (obNeedsRegExp.get() == aSettings.mobNeedsRegExp.get());

                // check whether fields are connected by 'or' (see comments above).
                if( rColumnFields.size() >= 2 )
                    for( ApiFilterSettings::FilterFieldVector::iterator aSIt = rColumnFields.begin() + 1, aSEnd = rColumnFields.end(); !bHasOrConnection && (aSIt != aSEnd); ++aSIt )
                        bHasOrConnection = aSIt->Connection == FilterConnection_OR;

                /*  Skip the column filter, if no filter fields have been created,
                    if the number of new filter fields would exceed the total limit
                    of filter fields, or if the mode for regular expressions of the
                    filter column does not fit. */
                if( !rColumnFields.empty() && (nNewCount <= nMaxCount) && bRegExpCompatible )
                {
                    /*  Add 'and' connection to the first filter field to connect
                        it to the existing filter fields of other columns. */
                    rColumnFields[ 0 ].Connection = FilterConnection_AND;

                    // insert the new filter fields
                    aFilterFields.insert( aFilterFields.end(), rColumnFields.begin(), rColumnFields.end() );

                    // update the regular expressions mode
                    obNeedsRegExp.assignIfUsed( aSettings.mobNeedsRegExp );
                }
            }

            // insert all filter fields to the filter descriptor
            if( !aFilterFields.empty() )
                rxFilterDesc->setFilterFields3( ContainerHelper::vectorToSequence( aFilterFields ) );

            // regular expressions
            bool bUseRegExp = obNeedsRegExp.get( false );
            aDescProps.setProperty( PROP_UseRegularExpressions, bUseRegExp );
        }
    }

    AutoFilterBuffer::AutoFilterBuffer( const WorkbookHelper& rHelper ) :
        WorkbookHelper( rHelper )
    {
    }

    AutoFilter& AutoFilterBuffer::createAutoFilter()
    {
        AutoFilterVector::value_type xAutoFilter( new AutoFilter( *this ) );
        maAutoFilters.push_back( xAutoFilter );
        return *xAutoFilter;
    }

    void AutoFilterBuffer::finalizeImport( sal_Int16 nSheet )
    {
        // rely on existence of the defined name '_FilterDatabase' containing the range address of the filtered area
        if( const DefinedName* pFilterDBName = getDefinedNames().getByBuiltinId( BIFF_DEFNAME_FILTERDATABASE, nSheet ).get() )
        {
            ScRange aFilterRange;
            if( pFilterDBName->getAbsoluteRange( aFilterRange ) && (aFilterRange.aStart.Tab() == nSheet) )
            {
                // use the same name for the database range as used for the defined name '_FilterDatabase'
                Reference< XDatabaseRange > xDatabaseRange = createUnnamedDatabaseRangeObject( aFilterRange );
                // first, try to create an auto filter
                bool bHasAutoFilter = finalizeImport( xDatabaseRange );
                // no success: try to create an advanced filter
                if( !bHasAutoFilter && xDatabaseRange.is() )
                {
                    // the built-in defined name 'Criteria' must exist
                    if( const DefinedName* pCriteriaName = getDefinedNames().getByBuiltinId( BIFF_DEFNAME_CRITERIA, nSheet ).get() )
                    {
                        ScRange aCriteriaRange;
                        if( pCriteriaName->getAbsoluteRange( aCriteriaRange ) )
                        {
                            // set some common properties for the filter descriptor
                            PropertySet aDescProps( xDatabaseRange->getFilterDescriptor() );
                            aDescProps.setProperty( PROP_IsCaseSensitive, false );
                            aDescProps.setProperty( PROP_SkipDuplicates, false );
                            aDescProps.setProperty( PROP_Orientation, TableOrientation_ROWS );
                            aDescProps.setProperty( PROP_ContainsHeader, true );
                            // criteria range may contain wildcards, but these are incompatible with REs
                            aDescProps.setProperty( PROP_UseRegularExpressions, false );

                            // position of output data (if built-in defined name 'Extract' exists)
                            DefinedNameRef xExtractName = getDefinedNames().getByBuiltinId( BIFF_DEFNAME_EXTRACT, nSheet );
                            ScRange aOutputRange;
                            bool bHasOutputRange = xExtractName.get() && xExtractName->getAbsoluteRange( aOutputRange );
                            aDescProps.setProperty( PROP_CopyOutputData, bHasOutputRange );
                            if( bHasOutputRange )
                            {
                                aDescProps.setProperty( PROP_SaveOutputPosition, true );
                                aDescProps.setProperty( PROP_OutputPosition, CellAddress( aOutputRange.aStart.Tab(), aOutputRange.aStart.Col(), aOutputRange.aStart.Row() ) );
                            }

                            /*  Properties of the database range (must be set after
                                modifying properties of the filter descriptor,
                                otherwise the 'FilterCriteriaSource' property gets
                                deleted). */
                            PropertySet aRangeProps( xDatabaseRange );
                            aRangeProps.setProperty( PROP_AutoFilter, false );
                            aRangeProps.setProperty( PROP_FilterCriteriaSource,
                                                     CellRangeAddress( aCriteriaRange.aStart.Tab(),
                                                                       aCriteriaRange.aStart.Col(), aCriteriaRange.aStart.Row(),
                                                                       aCriteriaRange.aEnd.Col(), aCriteriaRange.aEnd.Row() ));
                        }
                    }
                }
            }
        }
    }

    bool AutoFilterBuffer::finalizeImport( const Reference< XDatabaseRange >& rxDatabaseRange )
    {
        AutoFilter* pAutoFilter = getActiveAutoFilter();
        if( pAutoFilter && rxDatabaseRange.is() ) try
        {
            // the property 'AutoFilter' enables the drop-down buttons
            PropertySet aRangeProps( rxDatabaseRange );
            aRangeProps.setProperty( PROP_AutoFilter, true );
            // convert filter settings using the filter descriptor of the database range
            Reference< XSheetFilterDescriptor3 > xFilterDesc( rxDatabaseRange->getFilterDescriptor(), UNO_QUERY_THROW );
            pAutoFilter->finalizeImport( xFilterDesc );
            // return true to indicate enabled autofilter
            return true;
        }
        catch( Exception& )
        {
        }
        return false;
    }

    AutoFilter* AutoFilterBuffer::getActiveAutoFilter()
    {
        // Excel expects not more than one auto filter per sheet or table
        OSL_ENSURE( maAutoFilters.size() <= 1, "AutoFilterBuffer::getActiveAutoFilter - too many auto filters" );
        // stick to the last imported auto filter
        return maAutoFilters.empty() ? nullptr : maAutoFilters.back().get();
    }

    } // namespace xls
    } // namespace oox

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

↑ V601 The bool type is implicitly cast to the class type. Inspect the second argument.

↑ V601 The 'false' value becomes a class object. Inspect the second argument.

↑ V601 The 'false' value becomes a class object. Inspect the second argument.

↑ V601 The 'false' value becomes a class object. Inspect the second argument.

↑ V601 The 'true' value becomes a class object. Inspect the second argument.

↑ V601 The 'false' value becomes a class object. Inspect the second argument.

↑ V601 The bool type is implicitly cast to the class type. Inspect the second argument.

↑ V601 The 'false' value becomes a class object. Inspect the second argument.

↑ V601 The 'true' value becomes a class object. Inspect the second argument.

↑ V601 The 'false' value becomes a class object. Inspect the second argument.

↑ V601 The 'true' value becomes a class object. Inspect the second argument.

↑ V601 The 'true' value becomes a class object. Inspect the second argument.

↑ V601 The 'false' value becomes a class object. Inspect the second argument.