Encapsulated empty and non-empty filter criteria.

Because those two conditions were not very obvious.
diff --git a/sc/inc/queryentry.hxx b/sc/inc/queryentry.hxx
index c0ce6e4..64191414 100644
--- a/sc/inc/queryentry.hxx
+++ b/sc/inc/queryentry.hxx
@@ -52,8 +52,8 @@ struct ScQueryEntry
        double        mfVal;
        rtl::OUString maString;

        bool operator== (const Item& r) const;
        Item();
        bool operator== (const Item& r) const;
    };
    typedef std::vector<Item> QueryItemsType;

@@ -71,6 +71,10 @@ struct ScQueryEntry
    // creates pSearchParam and pSearchText if necessary, always RegExp!
    utl::TextSearch* GetSearchTextPtr( bool bCaseSens ) const;

    SC_DLLPUBLIC void SetQueryByEmpty();
    SC_DLLPUBLIC bool IsQueryByEmpty() const;
    SC_DLLPUBLIC void SetQueryByNonEmpty();
    SC_DLLPUBLIC bool IsQueryByNonEmpty() const;
    SC_DLLPUBLIC const Item& GetQueryItem() const;
    SC_DLLPUBLIC Item& GetQueryItem();
    void            Clear();
diff --git a/sc/inc/queryparam.hxx b/sc/inc/queryparam.hxx
index 9bf9be1..d04f7b4 100644
--- a/sc/inc/queryparam.hxx
+++ b/sc/inc/queryparam.hxx
@@ -34,15 +34,6 @@

#include <boost/ptr_container/ptr_vector.hpp>

/*
 * dialog returns the special field values "empty"/"not empty"
 * as constants SC_EMPTYFIELDS and SC_NONEMPTYFIELDS respectively in nVal in
 * conjuctions with the flag bQueryByString = FALSE.
 */

#define SC_EMPTYFIELDS      ((double)0x0042)
#define SC_NONEMPTYFIELDS   ((double)0x0043)

struct ScDBQueryParamInternal;
struct ScQueryEntry;

diff --git a/sc/qa/unit/ucalc.cxx b/sc/qa/unit/ucalc.cxx
index 8621dfc..24e183a 100644
--- a/sc/qa/unit/ucalc.cxx
+++ b/sc/qa/unit/ucalc.cxx
@@ -2255,9 +2255,7 @@ void Test::testAutofilter()
    // Filter for non-empty cells by column C.
    rEntry.bDoQuery = true;
    rEntry.nField = 2;
    rEntry.GetQueryItem().meType = ScQueryEntry::ByValue;
    rEntry.GetQueryItem().maString = rtl::OUString();
    rEntry.GetQueryItem().mfVal = SC_NONEMPTYFIELDS;
    rEntry.SetQueryByNonEmpty();
    m_pDoc->Query(0, aParam, true);

    // only row 3 should be hidden.  The rest should be visible.
@@ -2269,7 +2267,7 @@ void Test::testAutofilter()
    CPPUNIT_ASSERT_MESSAGE("row 4 and down should be visible.", !bHidden && nRow1 == 3 && nRow2 == MAXROW);

    // Now, filter for empty cells by column C.
    rEntry.GetQueryItem().mfVal = SC_EMPTYFIELDS;
    rEntry.SetQueryByEmpty();
    m_pDoc->Query(0, aParam, true);

    // Now, only row 1 and 3, and 6 and down should be visible.
diff --git a/sc/source/core/data/dpshttab.cxx b/sc/source/core/data/dpshttab.cxx
index fc4072d..f10d62b 100644
--- a/sc/source/core/data/dpshttab.cxx
+++ b/sc/source/core/data/dpshttab.cxx
@@ -78,19 +78,17 @@ ScSheetDPData::ScSheetDPData(ScDocument* pD, const ScSheetSourceDesc& rDesc, con
        {
            ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
            pSpecial[j] = false;
            if (rItem.meType != ScQueryEntry::ByString)
            {
                if (rItem.maString.isEmpty() &&
                   ((rItem.mfVal == SC_EMPTYFIELDS) || (rItem.mfVal == SC_NONEMPTYFIELDS)))
                    pSpecial[j] = true;
            }
            else
            if (rItem.meType == ScQueryEntry::ByString)
            {
                sal_uInt32 nIndex = 0;
                bool bNumber = pD->GetFormatTable()->IsNumberFormat(
                    rItem.maString, nIndex, rItem.mfVal);
                rItem.meType = bNumber ? ScQueryEntry::ByValue : ScQueryEntry::ByString;
            }
            else if (rEntry.IsQueryByEmpty() || rEntry.IsQueryByNonEmpty())
            {
                pSpecial[j] = true;
            }
        }
    }
}
diff --git a/sc/source/core/data/dptablecache.cxx b/sc/source/core/data/dptablecache.cxx
index 4c894d7..0ebf847 100644
--- a/sc/source/core/data/dptablecache.cxx
+++ b/sc/source/core/data/dptablecache.cxx
@@ -618,10 +618,13 @@ bool ScDPCache::ValidQuery( SCROW nRow, const ScQueryParam &rParam, bool *pSpeci

        if (pSpecial && pSpecial[i])
        {
            if (rItem.mfVal == SC_EMPTYFIELDS)
                bOk = ! pCellData->IsHasData();
            else // if (rEntry.nVal == SC_NONEMPTYFIELDS)
            if (rEntry.IsQueryByEmpty())
                bOk = !pCellData->IsHasData();
            else
            {
                OSL_ASSERT(rEntry.IsQueryByNonEmpty());
                bOk =  pCellData->IsHasData();
            }
        }
        else if (rEntry.GetQueryItem().meType != ScQueryEntry::ByString && pCellData->IsValue())
        {   // by Value
diff --git a/sc/source/core/data/table3.cxx b/sc/source/core/data/table3.cxx
index 59738e4..16c4793 100644
--- a/sc/source/core/data/table3.cxx
+++ b/sc/source/core/data/table3.cxx
@@ -1190,10 +1190,13 @@ bool ScTable::ValidQuery(SCROW nRow, const ScQueryParam& rParam,

        if ( pSpecial && pSpecial[i] )
        {
            if (rItem.mfVal == SC_EMPTYFIELDS)
            if (rEntry.IsQueryByEmpty())
                bOk = !( aCol[rEntry.nField].HasDataAt( nRow ) );
            else // if (rEntry.nVal == SC_NONEMPTYFIELDS)
            else
            {
                OSL_ASSERT(rEntry.IsQueryByNonEmpty());
                bOk = aCol[rEntry.nField].HasDataAt( nRow );
            }
        }
        else if (isQueryByValue(*this, rItem, nCol, nRow, pCell))
        {
@@ -1655,7 +1658,7 @@ static void lcl_PrepareQuery( ScDocument* pDoc, ScTable* pTab, ScQueryParam& rPa
            else
            {
                // call from UNO or second call from autofilter
                if ( rItem.mfVal == SC_EMPTYFIELDS || rItem.mfVal == SC_NONEMPTYFIELDS )
                if (rEntry.IsQueryByEmpty() || rEntry.IsQueryByNonEmpty())
                {
                    pSpecial[i] = true;
                }
diff --git a/sc/source/core/tool/queryentry.cxx b/sc/source/core/tool/queryentry.cxx
index 0aba519..ec2cb6b 100644
--- a/sc/source/core/tool/queryentry.cxx
+++ b/sc/source/core/tool/queryentry.cxx
@@ -27,11 +27,21 @@
 */

#include "queryentry.hxx"
#include "queryparam.hxx"

#include <unotools/textsearch.hxx>
#include <unotools/transliterationwrapper.hxx>
#include <unotools/collatorwrapper.hxx>

/*
 * dialog returns the special field values "empty"/"not empty"
 * as constants SC_EMPTYFIELDS and SC_NONEMPTYFIELDS respectively in nVal in
 * conjuctions with the flag bQueryByString = FALSE.
 */

#define SC_EMPTYFIELDS      ((double)0x0042)
#define SC_NONEMPTYFIELDS   ((double)0x0043)

ScQueryEntry::Item::Item() :
    meType(ByValue), mfVal(0.0) {}

@@ -84,6 +94,50 @@ ScQueryEntry& ScQueryEntry::operator=( const ScQueryEntry& r )
    return *this;
}

void ScQueryEntry::SetQueryByEmpty()
{
    eOp = SC_EQUAL;
    Item& rItem = GetQueryItem();
    rItem.meType = ByValue;
    rItem.maString = rtl::OUString();
    rItem.mfVal = SC_EMPTYFIELDS;
}

bool ScQueryEntry::IsQueryByEmpty() const
{
    if (maQueryItems.size() > 1)
        // multi-item query.
        return false;

    const Item& rItem = GetQueryItem();
    return eOp == SC_EQUAL &&
        rItem.meType == ByValue &&
        rItem.maString.isEmpty() &&
        rItem.mfVal == SC_EMPTYFIELDS;
}

void ScQueryEntry::SetQueryByNonEmpty()
{
    eOp = SC_EQUAL;
    Item& rItem = GetQueryItem();
    rItem.meType = ByValue;
    rItem.maString = rtl::OUString();
    rItem.mfVal = SC_NONEMPTYFIELDS;
}

bool ScQueryEntry::IsQueryByNonEmpty() const
{
    if (maQueryItems.size() > 1)
        // multi-item query.
        return false;

    const Item& rItem = GetQueryItem();
    return eOp == SC_EQUAL &&
        rItem.meType == ByValue &&
        rItem.maString.isEmpty() &&
        rItem.mfVal == SC_NONEMPTYFIELDS;
}

const ScQueryEntry::Item& ScQueryEntry::GetQueryItem() const
{
    if (maQueryItems.size() > 1)
diff --git a/sc/source/filter/excel/excimp8.cxx b/sc/source/filter/excel/excimp8.cxx
index c1a012a..4cd628f 100644
--- a/sc/source/filter/excel/excimp8.cxx
+++ b/sc/source/filter/excel/excimp8.cxx
@@ -673,18 +673,14 @@ void XclImpAutoFilterData::ReadAutoFilter( XclImpStream& rStrm )
                        bIgnore = (nBoolErr != 0);
                    break;
                    case EXC_AFTYPE_EMPTY:
                        rItem.meType = ScQueryEntry::ByValue;
                        rItem.mfVal = SC_EMPTYFIELDS;
                        aEntry.eOp = SC_EQUAL;
                        aEntry.SetQueryByEmpty();
                    break;
                    case EXC_AFTYPE_NOTEMPTY:
                        rItem.meType = ScQueryEntry::ByValue;
                        rItem.mfVal = SC_NONEMPTYFIELDS;
                        aEntry.eOp = SC_EQUAL;
                        aEntry.SetQueryByNonEmpty();
                    break;
                    default:
                        rStrm.Ignore( 8 );
                        bIgnore = sal_True;
                        bIgnore = true;
                }

                /*  #i39464# conflict, if two conditions of one column are 'OR'ed,
diff --git a/sc/source/filter/excel/excrecds.cxx b/sc/source/filter/excel/excrecds.cxx
index 2a59124..9e39fad 100644
--- a/sc/source/filter/excel/excrecds.cxx
+++ b/sc/source/filter/excel/excrecds.cxx
@@ -714,9 +714,9 @@ bool XclExpAutofilter::AddEntry( const ScQueryEntry& rEntry )
    bool bLen = sText.Len() > 0;

    // empty/nonempty fields
    if( !bLen && (rItem.mfVal == SC_EMPTYFIELDS) )
    if (rEntry.IsQueryByEmpty())
        bConflict = !AddCondition( rEntry.eConnect, EXC_AFTYPE_EMPTY, EXC_AFOPER_NONE, 0.0, NULL, true );
    else if( !bLen && (rItem.mfVal == SC_NONEMPTYFIELDS) )
    else if(rEntry.IsQueryByNonEmpty())
        bConflict = !AddCondition( rEntry.eConnect, EXC_AFTYPE_NOTEMPTY, EXC_AFOPER_NONE, 0.0, NULL, true );
    // other conditions
    else
diff --git a/sc/source/filter/xml/XMLExportDataPilot.cxx b/sc/source/filter/xml/XMLExportDataPilot.cxx
index 83a6d76..b207a46 100644
--- a/sc/source/filter/xml/XMLExportDataPilot.cxx
+++ b/sc/source/filter/xml/XMLExportDataPilot.cxx
@@ -78,28 +78,17 @@ ScXMLExportDataPilot::~ScXMLExportDataPilot()
{
}

rtl::OUString ScXMLExportDataPilot::getDPOperatorXML(const ScQueryOp aFilterOperator, const bool bUseRegularExpressions,
    const bool bIsString, const double dVal, const String& sVal) const
rtl::OUString ScXMLExportDataPilot::getDPOperatorXML(
    const ScQueryOp aFilterOperator, const bool bUseRegularExpressions) const
{
    switch (aFilterOperator)
    {
        case SC_EQUAL :
        {
            rtl::OUString sReturn;
            if (bUseRegularExpressions)
                sReturn = GetXMLToken(XML_MATCH);
                return GetXMLToken(XML_MATCH);
            else
                sReturn = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("="));

            if (!bIsString && sVal == EMPTY_STRING)
            {
                if (dVal == SC_EMPTYFIELDS)
                    sReturn = GetXMLToken(XML_EMPTY);
                else if (dVal == SC_NONEMPTYFIELDS)
                    sReturn = GetXMLToken(XML_NOEMPTY);
            }

            return sReturn;
                return rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("="));
        }
        case SC_NOT_EQUAL :
        {
@@ -146,9 +135,20 @@ void ScXMLExportDataPilot::WriteDPCondition(const ScQueryEntry& aQueryEntry, boo
        rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_DATA_TYPE, XML_NUMBER);
        rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_VALUE, rQueryStr);
    }
    rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_OPERATOR,
                         getDPOperatorXML(aQueryEntry.eOp, bUseRegularExpressions,
                                          rItem.meType == ScQueryEntry::ByString, rItem.mfVal, rQueryStr));

    if (aQueryEntry.IsQueryByEmpty())
    {
        rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_OPERATOR, GetXMLToken(XML_EMPTY));
    }
    else if (aQueryEntry.IsQueryByNonEmpty())
    {
        rExport.AddAttribute(XML_NAMESPACE_TABLE, XML_OPERATOR, GetXMLToken(XML_NOEMPTY));
    }
    else
        rExport.AddAttribute(
            XML_NAMESPACE_TABLE, XML_OPERATOR,
            getDPOperatorXML(aQueryEntry.eOp, bUseRegularExpressions));

    SvXMLElementExport aElemC(rExport, XML_NAMESPACE_TABLE, XML_FILTER_CONDITION, true, true);
}

diff --git a/sc/source/filter/xml/XMLExportDataPilot.hxx b/sc/source/filter/xml/XMLExportDataPilot.hxx
index 5ea7bf8..e16cd63 100644
--- a/sc/source/filter/xml/XMLExportDataPilot.hxx
+++ b/sc/source/filter/xml/XMLExportDataPilot.hxx
@@ -50,8 +50,7 @@ class ScXMLExportDataPilot
    ScXMLExport&        rExport;
    ScDocument*         pDoc;

    rtl::OUString getDPOperatorXML(const ScQueryOp aFilterOperator, const bool bUseRegularExpressions,
                                    const bool bIsString, const double dVal, const String& sVal) const;
    rtl::OUString getDPOperatorXML(const ScQueryOp aFilterOperator, const bool bUseRegularExpressions) const;
    void WriteDPCondition(const ScQueryEntry& aQueryEntry, bool bIsCaseSensitive, bool bUseRegularExpressions);
    void WriteDPFilter(const ScQueryParam& aQueryParam);

diff --git a/sc/source/filter/xml/XMLExportDatabaseRanges.cxx b/sc/source/filter/xml/XMLExportDatabaseRanges.cxx
index 8ec3c44..9815feb 100644
--- a/sc/source/filter/xml/XMLExportDatabaseRanges.cxx
+++ b/sc/source/filter/xml/XMLExportDatabaseRanges.cxx
@@ -407,14 +407,11 @@ private:
                return GetXMLToken(XML_ENDS_WITH);
            case SC_EQUAL:
            {
                const ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
                if (!rItem.meType != ScQueryEntry::ByString && rItem.maString.isEmpty())
                {
                    if (rItem.mfVal == SC_EMPTYFIELDS)
                        return GetXMLToken(XML_EMPTY);
                    else if (rItem.mfVal == SC_NONEMPTYFIELDS)
                        return GetXMLToken(XML_NOEMPTY);
                }
                if (rEntry.IsQueryByEmpty())
                    return GetXMLToken(XML_EMPTY);
                else if (rEntry.IsQueryByNonEmpty())
                    return GetXMLToken(XML_NOEMPTY);

                if (bRegExp)
                    return GetXMLToken(XML_MATCH);
                else
diff --git a/sc/source/filter/xml/xmlfilti.cxx b/sc/source/filter/xml/xmlfilti.cxx
index 0b7f37a1..5582e30 100644
--- a/sc/source/filter/xml/xmlfilti.cxx
+++ b/sc/source/filter/xml/xmlfilti.cxx
@@ -710,8 +710,8 @@ SvXMLImportContext *ScXMLDPConditionContext::CreateChildContext( sal_uInt16 nPre
    return new SvXMLImportContext( GetImport(), nPrefix, rLName );
}

void ScXMLDPConditionContext::getOperatorXML(const rtl::OUString sTempOperator, ScQueryOp& aFilterOperator, bool& bUseRegularExpressions,
                                            double& dVal) const
void ScXMLDPConditionContext::getOperatorXML(
    const rtl::OUString sTempOperator, ScQueryOp& aFilterOperator, bool& bUseRegularExpressions) const
{
    bUseRegularExpressions = false;
    if (IsXMLToken(sTempOperator, XML_MATCH))
@@ -732,8 +732,6 @@ void ScXMLDPConditionContext::getOperatorXML(const rtl::OUString sTempOperator, 
        aFilterOperator = SC_BOTPERC;
    else if (IsXMLToken(sTempOperator, XML_BOTTOM_VALUES))
        aFilterOperator = SC_BOTVAL;
    else if (IsXMLToken(sTempOperator, XML_EMPTY))
        dVal = SC_EMPTYFIELDS;
    else if (sTempOperator.compareToAscii(">") == 0)
        aFilterOperator = SC_GREATER;
    else if (sTempOperator.compareToAscii(">=") == 0)
@@ -742,8 +740,6 @@ void ScXMLDPConditionContext::getOperatorXML(const rtl::OUString sTempOperator, 
        aFilterOperator = SC_LESS;
    else if (sTempOperator.compareToAscii("<=") == 0)
        aFilterOperator = SC_LESS_EQUAL;
    else if (IsXMLToken(sTempOperator, XML_NOEMPTY))
        dVal = SC_NONEMPTYFIELDS;
    else if (IsXMLToken(sTempOperator, XML_TOP_PERCENT))
        aFilterOperator = SC_TOPPERC;
    else if (IsXMLToken(sTempOperator, XML_TOP_VALUES))
@@ -758,28 +754,29 @@ void ScXMLDPConditionContext::EndElement()
    else
        aFilterField.eConnect = SC_AND;
    pFilterContext->SetIsCaseSensitive(bIsCaseSensitive);
    bool bUseRegularExpressions;
    double dVal(0.0);
    getOperatorXML(sOperator, aFilterField.eOp, bUseRegularExpressions, dVal);
    pFilterContext->SetUseRegularExpressions(bUseRegularExpressions);
    aFilterField.nField = nField;
    ScQueryEntry::Item& rItem = aFilterField.GetQueryItem();
    if (IsXMLToken(sDataType, XML_NUMBER))
    {
        rItem.mfVal = sConditionValue.toDouble();
        rItem.maString = sConditionValue;
        rItem.meType = ScQueryEntry::ByValue;
        if (dVal != 0.0)
        {
            rItem.mfVal = dVal;
            rItem.maString = rtl::OUString();
        }
    }
    if (IsXMLToken(sOperator, XML_EMPTY))
        aFilterField.SetQueryByEmpty();
    else if (IsXMLToken(sOperator, XML_NOEMPTY))
        aFilterField.SetQueryByNonEmpty();
    else
    {
        rItem.maString = sConditionValue;
        rItem.meType = ScQueryEntry::ByString;
        rItem.mfVal = 0.0;
        bool bUseRegularExpressions = false;
        getOperatorXML(sOperator, aFilterField.eOp, bUseRegularExpressions);
        pFilterContext->SetUseRegularExpressions(bUseRegularExpressions);
        aFilterField.nField = nField;
        ScQueryEntry::Item& rItem = aFilterField.GetQueryItem();
        if (IsXMLToken(sDataType, XML_NUMBER))
        {
            rItem.mfVal = sConditionValue.toDouble();
            rItem.maString = sConditionValue;
            rItem.meType = ScQueryEntry::ByValue;
        }
        else
        {
            rItem.maString = sConditionValue;
            rItem.meType = ScQueryEntry::ByString;
            rItem.mfVal = 0.0;
        }
    }
    pFilterContext->AddFilterField(aFilterField);
}
diff --git a/sc/source/filter/xml/xmlfilti.hxx b/sc/source/filter/xml/xmlfilti.hxx
index 61838f2..454128b 100644
--- a/sc/source/filter/xml/xmlfilti.hxx
+++ b/sc/source/filter/xml/xmlfilti.hxx
@@ -303,8 +303,8 @@ public:
                                     const ::com::sun::star::uno::Reference<
                                          ::com::sun::star::xml::sax::XAttributeList>& xAttrList );

    void getOperatorXML(const rtl::OUString sTempOperator, ScQueryOp& aFilterOperator, bool& bUseRegularExpressions,
                        double& dVal) const;
    void getOperatorXML(
        const rtl::OUString sTempOperator, ScQueryOp& aFilterOperator, bool& bUseRegularExpressions) const;
    virtual void EndElement();
};

diff --git a/sc/source/ui/dbgui/filtdlg.cxx b/sc/source/ui/dbgui/filtdlg.cxx
index 0dccddd..74960bc 100644
--- a/sc/source/ui/dbgui/filtdlg.cxx
+++ b/sc/source/ui/dbgui/filtdlg.cxx
@@ -313,13 +313,12 @@ void ScFilterDlg::Init( const SfxItemSet& rArgSet )
            const ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
            nCondPos     = (sal_uInt16)rEntry.eOp;
            nFieldSelPos = GetFieldSelPos( static_cast<SCCOL>(rEntry.nField) );
            bool bEmptyString = rItem.maString.isEmpty();
            if (rItem.mfVal == SC_EMPTYFIELDS && rItem.meType != ScQueryEntry::ByString && bEmptyString)
            if (rEntry.IsQueryByEmpty())
            {
                aValStr = aStrEmpty;
                aCondLbArr[i]->Disable();
            }
            else if (rItem.mfVal == SC_NONEMPTYFIELDS && rItem.meType != ScQueryEntry::ByString && bEmptyString)
            else if (rEntry.IsQueryByNonEmpty())
            {
                aValStr = aStrNotEmpty;
                aCondLbArr[i]->Disable();
@@ -1149,15 +1148,11 @@ IMPL_LINK( ScFilterDlg, ValModifyHdl, ComboBox*, pEd )
        {
            if ( aStrEmpty.equals(aStrVal) )
            {
                rItem.maString = rtl::OUString();
                rItem.mfVal = SC_EMPTYFIELDS;
                rItem.meType = ScQueryEntry::ByValue;
                rEntry.SetQueryByEmpty();
            }
            else if ( aStrNotEmpty.equals(aStrVal) )
            {
                rItem.maString = rtl::OUString();
                rItem.mfVal = SC_NONEMPTYFIELDS;
                rItem.meType = ScQueryEntry::ByValue;
                rEntry.SetQueryByNonEmpty();
            }
            else
            {
@@ -1223,12 +1218,12 @@ void ScFilterDlg::RefreshEditRow( size_t nOffset )

            const ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
            const rtl::OUString& rQueryStr = rItem.maString;
            if (rItem.mfVal == SC_EMPTYFIELDS && rItem.meType != ScQueryEntry::ByString && rQueryStr.isEmpty())
            if (rEntry.IsQueryByEmpty())
            {
                aValStr = aStrEmpty;
                aCondLbArr[i]->Disable();
            }
            else if (rItem.mfVal == SC_NONEMPTYFIELDS && rItem.meType != ScQueryEntry::ByString && rQueryStr.isEmpty())
            else if (rEntry.IsQueryByNonEmpty())
            {
                aValStr = aStrNotEmpty;
                aCondLbArr[i]->Disable();
diff --git a/sc/source/ui/dbgui/pfiltdlg.cxx b/sc/source/ui/dbgui/pfiltdlg.cxx
index 593b696..687da91 100644
--- a/sc/source/ui/dbgui/pfiltdlg.cxx
+++ b/sc/source/ui/dbgui/pfiltdlg.cxx
@@ -217,13 +217,10 @@ void ScPivotFilterDlg::Init( const SfxItemSet& rArgSet )
            const ScQueryEntry& rEntry = theQueryData.GetEntry(i);
            const ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
            rtl::OUString aValStr = rItem.maString;
            if (rItem.meType != ScQueryEntry::ByString && aValStr.isEmpty())
            {
                if (rItem.mfVal == SC_EMPTYFIELDS)
                    aValStr = aStrEmpty;
                else if (rItem.mfVal == SC_NONEMPTYFIELDS)
                    aValStr = aStrNotEmpty;
            }
            if (rEntry.IsQueryByEmpty())
                aValStr = aStrEmpty;
            else if (rEntry.IsQueryByNonEmpty())
                aValStr = aStrNotEmpty;
            sal_uInt16  nCondPos     = (sal_uInt16)rEntry.eOp;
            sal_uInt16  nFieldSelPos = GetFieldSelPos( static_cast<SCCOL>(rEntry.nField) );

@@ -428,15 +425,13 @@ const ScQueryItem& ScPivotFilterDlg::GetOutputItem()
             */
            if ( aStrVal == aStrEmpty )
            {
                rItem.maString = rtl::OUString();
                rItem.mfVal = SC_EMPTYFIELDS;
                rItem.meType = ScQueryEntry::ByValue;
                OSL_ASSERT(eOp == SC_EQUAL);
                rEntry.SetQueryByEmpty();
            }
            else if ( aStrVal == aStrNotEmpty )
            {
                rItem.maString = rtl::OUString();
                rItem.mfVal = SC_NONEMPTYFIELDS;
                rItem.meType = ScQueryEntry::ByValue;
                OSL_ASSERT(eOp == SC_EQUAL);
                rEntry.SetQueryByNonEmpty();
            }
            else
            {
diff --git a/sc/source/ui/unoobj/datauno.cxx b/sc/source/ui/unoobj/datauno.cxx
index 0ea4eac..307d21a 100644
--- a/sc/source/ui/unoobj/datauno.cxx
+++ b/sc/source/ui/unoobj/datauno.cxx
@@ -1105,20 +1105,10 @@ void ScFilterDescriptorBase::fillQueryParam(
        case sheet::FilterOperator2::ENDS_WITH:             rEntry.eOp = SC_ENDS_WITH;          break;
        case sheet::FilterOperator2::DOES_NOT_END_WITH:     rEntry.eOp = SC_DOES_NOT_END_WITH;  break;
        case sheet::FilterOperator2::EMPTY:
            {
                rEntry.eOp = SC_EQUAL;
                rItem.mfVal = SC_EMPTYFIELDS;
                rItem.meType = ScQueryEntry::ByValue;
                rItem.maString = rtl::OUString();
            }
            rEntry.SetQueryByEmpty();
            break;
        case sheet::FilterOperator2::NOT_EMPTY:
            {
                rEntry.eOp = SC_EQUAL;
                rItem.mfVal = SC_NONEMPTYFIELDS;
                rItem.meType = ScQueryEntry::ByValue;
                rItem.maString = rtl::OUString();
            }
            rEntry.SetQueryByNonEmpty();
            break;
        default:
            OSL_FAIL("Falscher Query-enum");
@@ -1192,18 +1182,15 @@ uno::Sequence<sheet::TableFilterField> SAL_CALL ScFilterDescriptorBase::getFilte
            case SC_EQUAL:
                {
                    aField.Operator = sheet::FilterOperator_EQUAL;
                    if (!rItem.meType != ScQueryEntry::ByString && rItem.maString.isEmpty())
                    if (rEntry.IsQueryByEmpty())
                    {
                        if (rItem.mfVal == SC_EMPTYFIELDS)
                        {
                            aField.Operator = sheet::FilterOperator_EMPTY;
                            aField.NumericValue = 0;
                        }
                        else if (rItem.mfVal == SC_NONEMPTYFIELDS)
                        {
                            aField.Operator = sheet::FilterOperator_NOT_EMPTY;
                            aField.NumericValue = 0;
                        }
                        aField.Operator = sheet::FilterOperator_EMPTY;
                        aField.NumericValue = 0;
                    }
                    else if (rEntry.IsQueryByNonEmpty())
                    {
                        aField.Operator = sheet::FilterOperator_NOT_EMPTY;
                        aField.NumericValue = 0;
                    }
                }
                break;
@@ -1257,18 +1244,15 @@ throw(uno::RuntimeException)
        case SC_EQUAL:
            {
                aField.Operator = sheet::FilterOperator2::EQUAL;
                if (!rItem.meType != ScQueryEntry::ByString && rItem.maString.isEmpty())
                if (rEntry.IsQueryByEmpty())
                {
                    if (rItem.mfVal == SC_EMPTYFIELDS)
                    {
                        aField.Operator = sheet::FilterOperator2::EMPTY;
                        aField.NumericValue = 0;
                    }
                    else if (rItem.mfVal == SC_NONEMPTYFIELDS)
                    {
                        aField.Operator = sheet::FilterOperator2::NOT_EMPTY;
                        aField.NumericValue = 0;
                    }
                    aField.Operator = sheet::FilterOperator2::EMPTY;
                    aField.NumericValue = 0;
                }
                else if (rEntry.IsQueryByNonEmpty())
                {
                    aField.Operator = sheet::FilterOperator2::NOT_EMPTY;
                    aField.NumericValue = 0;
                }
            }
            break;
@@ -1336,20 +1320,10 @@ void SAL_CALL ScFilterDescriptorBase::setFilterFields(
            case sheet::FilterOperator_TOP_PERCENT:     rEntry.eOp = SC_TOPPERC;         break;
            case sheet::FilterOperator_BOTTOM_PERCENT:  rEntry.eOp = SC_BOTPERC;         break;
            case sheet::FilterOperator_EMPTY:
                {
                    rEntry.eOp = SC_EQUAL;
                    rItem.mfVal = SC_EMPTYFIELDS;
                    rItem.meType = ScQueryEntry::ByValue;
                    rItem.maString = rtl::OUString();
                }
                rEntry.SetQueryByEmpty();
                break;
            case sheet::FilterOperator_NOT_EMPTY:
                {
                    rEntry.eOp = SC_EQUAL;
                    rItem.mfVal = SC_NONEMPTYFIELDS;
                    rItem.meType = ScQueryEntry::ByValue;
                    rItem.maString = rtl::OUString();
                }
                rEntry.SetQueryByNonEmpty();
                break;
            default:
                OSL_FAIL("Falscher Query-enum");
diff --git a/sc/source/ui/view/gridwin.cxx b/sc/source/ui/view/gridwin.cxx
index 07d1191..8d4b080 100644
--- a/sc/source/ui/view/gridwin.cxx
+++ b/sc/source/ui/view/gridwin.cxx
@@ -1398,17 +1398,11 @@ void ScGridWindow::ExecFilter( sal_uLong nSel,
                    }
                    else if (nSel == SC_AUTOFILTER_EMPTY)
                    {
                        rNewEntry.eOp = SC_EQUAL;
                        rItem.maString = rtl::OUString();
                        rItem.meType = ScQueryEntry::ByValue;
                        rItem.mfVal  = SC_EMPTYFIELDS;
                        rNewEntry.SetQueryByEmpty();
                    }
                    else if (nSel == SC_AUTOFILTER_NOTEMPTY)
                    {
                        rNewEntry.eOp = SC_EQUAL;
                        rItem.maString = rtl::OUString();
                        rItem.meType = ScQueryEntry::ByValue;
                        rItem.mfVal = SC_NONEMPTYFIELDS;
                        rNewEntry.SetQueryByNonEmpty();
                    }
                    else
                    {