dbaccess/source/ui/dlg/queryfilter.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "queryfilter.hxx"
  21 #include "moduledbu.hxx"
  22 #include <com/sun/star/sdbc/DataType.hpp>
  23 #include <com/sun/star/util/Date.hpp>
  24 #include <com/sun/star/util/DateTime.hpp>
  25 #include <com/sun/star/util/Time.hpp>
  26 #include <com/sun/star/sdb/XSQLQueryComposer.hpp>
  27 #include <com/sun/star/sdbc/ColumnSearch.hpp>
  28 #include <com/sun/star/sdbcx/XColumnsSupplier.hpp>
  29 #include <com/sun/star/sdb/SQLFilterOperator.hpp>
  30 #include <com/sun/star/sdbc/XRow.hpp>
  31 #include <com/sun/star/sdbc/XResultSet.hpp>
  32 #include <com/sun/star/container/XNameAccess.hpp>
  33 #include <comphelper/string.hxx>
  34 #include <tools/diagnose_ex.h>
  35 #include <osl/diagnose.h>
  36 #include <connectivity/sqliterator.hxx>
  37 #include <connectivity/dbtools.hxx>
  38 #include "dbustrings.hrc"
  39 #include <com/sun/star/sdb/XSingleSelectQueryComposer.hpp>
  40
  41 using namespace dbaui;
  42 using namespace connectivity;
  43 using namespace ::com::sun::star::uno;
  44 using namespace ::com::sun::star::lang;
  45 using namespace ::com::sun::star::container;
  46 using namespace ::com::sun::star::util;
  47 using namespace ::com::sun::star::sdb;
  48 using namespace ::com::sun::star::sdbc;
  49 using namespace ::com::sun::star::sdbcx;
  50 using namespace ::com::sun::star::beans;
  51
  52 void Replace_OS_PlaceHolder(OUString& aString)
  53 {
  54     aString = aString.replaceAll( "*", "%" );
  55     aString = aString.replaceAll( "?", "_" );
  56 }
  57
  58 void Replace_SQL_PlaceHolder(OUString& aString)
  59 {
  60     aString = aString.replaceAll( "%", "*" );
  61     aString = aString.replaceAll( "_", "?" );
  62 }
  63
  64
  65 DlgFilterCrit::DlgFilterCrit(vcl::Window * pParent,
  66                              const Reference< XComponentContext >& rxContext,
  67                              const Reference< XConnection>& _rxConnection,
  68                              const Reference< XSingleSelectQueryComposer >& _rxComposer,
  69                              const Reference< XNameAccess>& _rxCols
  70                              )
  71     : ModalDialog(pParent, "QueryFilterDialog",
  72         "dbaccess/ui/queryfilterdialog.ui")
  73
  74     ,m_xQueryComposer(_rxComposer)
  75     ,m_xColumns( _rxCols )
  76     ,m_xConnection( _rxConnection )
  77     ,m_xMetaData( _rxConnection->getMetaData() )
  78     ,m_aPredicateInput( rxContext, _rxConnection, getParseContext() )
  79 {
  80     get(m_pLB_WHEREFIELD1, "field1");
  81     get(m_pLB_WHERECOMP1, "cond1");
  82     get(m_pET_WHEREVALUE1, "value1");
  83
  84     get(m_pLB_WHERECOND2, "op2");
  85     get(m_pLB_WHEREFIELD2, "field2");
  86     get(m_pLB_WHERECOMP2, "cond2");
  87     get(m_pET_WHEREVALUE2, "value2");
  88
  89     get(m_pLB_WHERECOND3, "op3");
  90     get(m_pLB_WHEREFIELD3, "field3");
  91     get(m_pLB_WHERECOMP3, "cond3");
  92     get(m_pET_WHEREVALUE3, "value3");
  93
  94     //set all condition preferred width to max width
  95     //if all entries exist
  96     Size aSize(m_pLB_WHERECOMP1->get_preferred_size());
  97     m_pLB_WHERECOMP1->set_width_request(aSize.Width());
  98     m_pLB_WHERECOMP2->set_width_request(aSize.Width());
  99     m_pLB_WHERECOMP3->set_width_request(aSize.Width());
 100     sal_uInt16 nEntryCount =  m_pLB_WHERECOMP1->GetEntryCount();
 101     for (sal_uInt16 i = 0; i < nEntryCount; ++i)
 102     {
 103         if (i > 0)
 104             m_aSTR_COMPARE_OPERATORS += ";";
 105         m_aSTR_COMPARE_OPERATORS += m_pLB_WHERECOMP1->GetEntry(i);
 106     }
 107     m_pLB_WHERECOMP1->Clear();
 108
 109     // ... also write it into the remaining fields
 110     Sequence< OUString> aNames = m_xColumns->getElementNames();
 111     const OUString* pIter = aNames.getConstArray();
 112     const OUString* pEnd   = pIter + aNames.getLength();
 113     Reference<XPropertySet> xColumn;
 114     for(;pIter != pEnd;++pIter)
 115     {
 116         try
 117         {
 118             xColumn.set( m_xColumns->getByName( *pIter ), UNO_QUERY_THROW );
 119
 120             sal_Int32 nDataType( 0 );
 121             OSL_VERIFY( xColumn->getPropertyValue( PROPERTY_TYPE ) >>= nDataType );
 122             sal_Int32 eColumnSearch = ::dbtools::getSearchColumnFlag( m_xConnection, nDataType );
 123             if ( eColumnSearch == ColumnSearch::NONE )
 124                 continue;
 125
 126             bool bIsSearchable( true );
 127             OSL_VERIFY( xColumn->getPropertyValue( PROPERTY_ISSEARCHABLE ) >>= bIsSearchable );
 128             if ( !bIsSearchable )
 129                 continue;
 130         }
 131         catch( const Exception& )
 132         {
 133             DBG_UNHANDLED_EXCEPTION();
 134         }
 135         m_pLB_WHEREFIELD1->InsertEntry( *pIter );
 136         m_pLB_WHEREFIELD2->InsertEntry( *pIter );
 137         m_pLB_WHEREFIELD3->InsertEntry( *pIter );
 138     }
 139
 140     Reference<XNameAccess> xSelectColumns = Reference<XColumnsSupplier>(m_xQueryComposer,UNO_QUERY)->getColumns();
 141     aNames = xSelectColumns->getElementNames();
 142     pIter = aNames.getConstArray();
 143     pEnd   = pIter + aNames.getLength();
 144     for(;pIter != pEnd;++pIter)
 145     {
 146         // don't insert a column name twice
 147         if ( !m_xColumns->hasByName(*pIter) )
 148         {
 149             xColumn.set(xSelectColumns->getByName(*pIter),UNO_QUERY);
 150             OSL_ENSURE(xColumn.is(),"DlgFilterCrit::DlgFilterCrit: Column is null!");
 151             sal_Int32 nDataType(0);
 152             xColumn->getPropertyValue(PROPERTY_TYPE) >>= nDataType;
 153             sal_Int32 eColumnSearch = dbtools::getSearchColumnFlag(m_xConnection,nDataType);
 154             // TODO
 155             // !pColumn->IsFunction()
 156             if(eColumnSearch != ColumnSearch::NONE)
 157             {
 158                 m_pLB_WHEREFIELD1->InsertEntry( *pIter );
 159                 m_pLB_WHEREFIELD2->InsertEntry( *pIter );
 160                 m_pLB_WHEREFIELD3->InsertEntry( *pIter );
 161             }
 162         }
 163     }
 164     // initialize the listboxes with noEntry
 165     m_pLB_WHEREFIELD1->SelectEntryPos(0);
 166     m_pLB_WHEREFIELD2->SelectEntryPos(0);
 167     m_pLB_WHEREFIELD3->SelectEntryPos(0);
 168
 169     // insert the criteria into the dialog
 170     Sequence<Sequence<PropertyValue > > aValues = m_xQueryComposer->getStructuredFilter();
 171     fillLines(aValues);
 172     aValues = m_xQueryComposer->getStructuredHavingClause();
 173     fillLines(aValues);
 174
 175     EnableLines();
 176
 177     m_pLB_WHEREFIELD1->SetSelectHdl(LINK(this,DlgFilterCrit,ListSelectHdl));
 178     m_pLB_WHEREFIELD2->SetSelectHdl(LINK(this,DlgFilterCrit,ListSelectHdl));
 179     m_pLB_WHEREFIELD3->SetSelectHdl(LINK(this,DlgFilterCrit,ListSelectHdl));
 180
 181     m_pLB_WHERECOMP1->SetSelectHdl(LINK(this,DlgFilterCrit,ListSelectCompHdl));
 182     m_pLB_WHERECOMP2->SetSelectHdl(LINK(this,DlgFilterCrit,ListSelectCompHdl));
 183     m_pLB_WHERECOMP3->SetSelectHdl(LINK(this,DlgFilterCrit,ListSelectCompHdl));
 184
 185     m_pET_WHEREVALUE1->SetLoseFocusHdl( LINK( this, DlgFilterCrit, PredicateLoseFocus ) );
 186     m_pET_WHEREVALUE2->SetLoseFocusHdl( LINK( this, DlgFilterCrit, PredicateLoseFocus ) );
 187     m_pET_WHEREVALUE3->SetLoseFocusHdl( LINK( this, DlgFilterCrit, PredicateLoseFocus ) );
 188
 189     if ( m_pET_WHEREVALUE1->IsEnabled() )
 190         m_pET_WHEREVALUE1->GrabFocus();
 191 }
 192
 193 DlgFilterCrit::~DlgFilterCrit()
 194 {
 195     disposeOnce();
 196 }
 197
 198 void DlgFilterCrit::dispose()
 199 {
 200     m_pLB_WHEREFIELD1.clear();
 201     m_pLB_WHERECOMP1.clear();
 202     m_pET_WHEREVALUE1.clear();
 203     m_pLB_WHERECOND2.clear();
 204     m_pLB_WHEREFIELD2.clear();
 205     m_pLB_WHERECOMP2.clear();
 206     m_pET_WHEREVALUE2.clear();
 207     m_pLB_WHERECOND3.clear();
 208     m_pLB_WHEREFIELD3.clear();
 209     m_pLB_WHERECOMP3.clear();
 210     m_pET_WHEREVALUE3.clear();
 211     ModalDialog::dispose();
 212 }
 213
 214 #define LbText(x)       ((x).GetSelectEntry())
 215 #define LbPos(x)        ((x).GetSelectEntryPos())
 216
 217 sal_Int32 DlgFilterCrit::GetOSQLPredicateType( const OUString& _rSelectedPredicate ) const
 218 {
 219     sal_Int32 nPredicateIndex = -1;
 220     for ( sal_Int32 i=0; i < comphelper::string::getTokenCount(m_aSTR_COMPARE_OPERATORS, ';'); ++i)
 221         if ( m_aSTR_COMPARE_OPERATORS.getToken(i, ';') == _rSelectedPredicate )
 222         {
 223             nPredicateIndex = i;
 224             break;
 225         }
 226
 227     sal_Int32 nPredicateType = SQLFilterOperator::NOT_SQLNULL;
 228     switch ( nPredicateIndex )
 229     {
 230     case 0:
 231         nPredicateType = SQLFilterOperator::EQUAL;
 232         break;
 233     case 1:
 234         nPredicateType = SQLFilterOperator::NOT_EQUAL;
 235         break;
 236     case 2:
 237         nPredicateType = SQLFilterOperator::LESS;
 238         break;
 239     case 3:
 240         nPredicateType = SQLFilterOperator::LESS_EQUAL;
 241         break;
 242     case 4:
 243         nPredicateType = SQLFilterOperator::GREATER;
 244         break;
 245     case 5:
 246         nPredicateType = SQLFilterOperator::GREATER_EQUAL;
 247         break;
 248     case 6:
 249         nPredicateType = SQLFilterOperator::LIKE;
 250         break;
 251     case 7:
 252         nPredicateType = SQLFilterOperator::NOT_LIKE;
 253         break;
 254     case 8:
 255         nPredicateType = SQLFilterOperator::SQLNULL;
 256         break;
 257     case 9:
 258         nPredicateType = SQLFilterOperator::NOT_SQLNULL;
 259         break;
 260     default:
 261         OSL_FAIL( "DlgFilterCrit::GetOSQLPredicateType: unknown predicate string!" );
 262         break;
 263     }
 264
 265     return nPredicateType;
 266 }
 267
 268 sal_uInt16 DlgFilterCrit::GetSelectionPos(sal_Int32 eType,const ListBox& rListBox)
 269 {
 270     sal_uInt16 nPos;
 271     switch(eType)
 272     {
 273         case SQLFilterOperator::EQUAL:
 274             nPos = 0;
 275             break;
 276         case SQLFilterOperator::NOT_EQUAL:
 277             nPos = 1;
 278             break;
 279         case SQLFilterOperator::LESS:
 280             nPos = 2;
 281             break;
 282         case SQLFilterOperator::LESS_EQUAL:
 283             nPos = 3;
 284             break;
 285         case SQLFilterOperator::GREATER:
 286             nPos = 4;
 287             break;
 288         case SQLFilterOperator::GREATER_EQUAL:
 289             nPos = 5;
 290             break;
 291         case SQLFilterOperator::NOT_LIKE:
 292             nPos = rListBox.GetEntryCount() > 2 ? rListBox.GetEntryCount()-3 : 0;
 293             break;
 294         case SQLFilterOperator::LIKE:
 295             nPos = rListBox.GetEntryCount() > 2 ? rListBox.GetEntryCount()-4 : 1;
 296             break;
 297         case SQLFilterOperator::SQLNULL:
 298             nPos = rListBox.GetEntryCount()-2;
 299             break;
 300         case SQLFilterOperator::NOT_SQLNULL:
 301             nPos = rListBox.GetEntryCount()-1;
 302             break;
 303         default:
 304             //  TODO  What value should this be?
 305             nPos = 0;
 306             break;
 307     }
 308     return nPos;
 309 }
 310
 311 bool DlgFilterCrit::getCondition(const ListBox& _rField,const ListBox& _rComp,const Edit& _rValue,PropertyValue& _rFilter) const
 312 {
 313     bool bHaving = false;
 314     try
 315     {
 316         OUString sTableName;
 317         _rFilter.Name = _rField.GetSelectEntry();
 318         Reference< XPropertySet > xColumn = getQueryColumn(_rFilter.Name);
 319         if ( xColumn.is() )
 320         {
 321             bool bFunction = false;
 322             Reference< XPropertySetInfo > xInfo = xColumn->getPropertySetInfo();
 323             if ( xInfo->hasPropertyByName(PROPERTY_REALNAME) )
 324             {
 325                 if ( xInfo->hasPropertyByName(PROPERTY_TABLENAME) )
 326                 {
 327                     xColumn->getPropertyValue(PROPERTY_TABLENAME)   >>= sTableName;
 328                     if ( !sTableName.isEmpty() )
 329                     {
 330                         // properly quote all parts of the table name, so
 331                         // e.g. <schema>.<table> becomes "<schema>"."<table>"
 332                         OUString aCatlog,aSchema,aTable;
 333                         ::dbtools::qualifiedNameComponents( m_xMetaData, sTableName, aCatlog, aSchema, aTable, ::dbtools::eInDataManipulation );
 334                         sTableName = ::dbtools::composeTableName( m_xMetaData, aCatlog, aSchema, aTable, true, ::dbtools::eInDataManipulation );
 335                     }
 336                 }
 337                 xColumn->getPropertyValue(PROPERTY_REALNAME)    >>= _rFilter.Name;
 338                 static const char sAgg[] = "AggregateFunction";
 339                 if ( xInfo->hasPropertyByName(sAgg) )
 340                     xColumn->getPropertyValue(sAgg) >>= bHaving;
 341                 static const char sFunction[] = "Function";
 342                 if ( xInfo->hasPropertyByName(sFunction) )
 343                     xColumn->getPropertyValue(sFunction) >>= bFunction;
 344             }
 345             if ( !bFunction )
 346             {
 347                 const OUString aQuote    = m_xMetaData.is() ? m_xMetaData->getIdentifierQuoteString() : OUString();
 348                 _rFilter.Name = ::dbtools::quoteName(aQuote,_rFilter.Name);
 349                 if ( !sTableName.isEmpty() )
 350                 {
 351                     static const char sSep[] = ".";
 352                     sTableName += sSep;
 353                     sTableName += _rFilter.Name;
 354                     _rFilter.Name = sTableName;
 355                 }
 356             }
 357         }
 358     }
 359     catch(const Exception&)
 360     {
 361     }
 362
 363     _rFilter.Handle = GetOSQLPredicateType( _rComp.GetSelectEntry() );
 364     if ( SQLFilterOperator::SQLNULL != _rFilter.Handle && _rFilter.Handle != SQLFilterOperator::NOT_SQLNULL )
 365     {
 366         OUString sPredicateValue;
 367         m_aPredicateInput.getPredicateValue( _rValue.GetText(), getMatchingColumn( _rValue ) ) >>= sPredicateValue;
 368         if ( _rFilter.Handle == SQLFilterOperator::LIKE ||
 369              _rFilter.Handle == SQLFilterOperator::NOT_LIKE )
 370             ::Replace_OS_PlaceHolder( sPredicateValue );
 371         _rFilter.Value <<= OUString(sPredicateValue);
 372     }
 373     return bHaving;
 374 }
 375
 376 Reference< XPropertySet > DlgFilterCrit::getColumn( const OUString& _rFieldName ) const
 377 {
 378     Reference< XPropertySet > xColumn;
 379     try
 380     {
 381         if ( m_xColumns.is() && m_xColumns->hasByName( _rFieldName ) )
 382             m_xColumns->getByName( _rFieldName ) >>= xColumn;
 383
 384         Reference< XNameAccess> xColumns = Reference< XColumnsSupplier >(m_xQueryComposer,UNO_QUERY)->getColumns();
 385         if ( xColumns.is() && !xColumn.is() )
 386         {
 387             Sequence< OUString> aSeq = xColumns->getElementNames();
 388             const OUString* pIter = aSeq.getConstArray();
 389             const OUString* pEnd   = pIter + aSeq.getLength();
 390             for(;pIter != pEnd;++pIter)
 391             {
 392                 Reference<XPropertySet> xProp(xColumns->getByName(*pIter),UNO_QUERY);
 393                 if ( xProp.is() && xProp->getPropertySetInfo()->hasPropertyByName(PROPERTY_REALNAME) )
 394                 {
 395                     OUString sRealName;
 396                     xProp->getPropertyValue(PROPERTY_REALNAME)  >>= sRealName;
 397                     if ( sRealName == _rFieldName )
 398                     {
 399                         if ( m_xColumns.is() && m_xColumns->hasByName( *pIter ) )
 400                             m_xColumns->getByName( *pIter ) >>= xColumn;
 401                         break;
 402                     }
 403                 }
 404             }
 405         }
 406     }
 407     catch( const Exception& )
 408     {
 409         DBG_UNHANDLED_EXCEPTION();
 410     }
 411
 412     return xColumn;
 413 }
 414
 415 Reference< XPropertySet > DlgFilterCrit::getQueryColumn( const OUString& _rFieldName ) const
 416 {
 417     Reference< XPropertySet > xColumn;
 418     try
 419     {
 420         Reference< XNameAccess> xColumns = Reference< XColumnsSupplier >(m_xQueryComposer,UNO_QUERY)->getColumns();
 421         if ( xColumns.is() && xColumns->hasByName( _rFieldName ) )
 422             xColumns->getByName( _rFieldName ) >>= xColumn;
 423     }
 424     catch( const Exception& )
 425     {
 426         DBG_UNHANDLED_EXCEPTION();
 427     }
 428
 429     return xColumn;
 430 }
 431
 432 Reference< XPropertySet > DlgFilterCrit::getMatchingColumn( const Edit& _rValueInput ) const
 433 {
 434     // the name
 435     OUString sField;
 436     if ( &_rValueInput == m_pET_WHEREVALUE1 )
 437     {
 438         sField = m_pLB_WHEREFIELD1->GetSelectEntry();
 439     }
 440     else if ( &_rValueInput == m_pET_WHEREVALUE2 )
 441     {
 442         sField = m_pLB_WHEREFIELD2->GetSelectEntry();
 443     }
 444     else if ( &_rValueInput == m_pET_WHEREVALUE3 )
 445     {
 446         sField = m_pLB_WHEREFIELD3->GetSelectEntry();
 447     }
 448     else {
 449         OSL_FAIL( "DlgFilterCrit::getMatchingColumn: invalid event source!" );
 450     }
 451
 452     // the field itself
 453     return getColumn( sField );
 454 }
 455
 456 IMPL_LINK( DlgFilterCrit, PredicateLoseFocus, Edit*, _pField )
 457 {
 458     OSL_ENSURE( _pField, "DlgFilterCrit::PredicateLoseFocus: invalid event source!" );
 459     if ( _pField )
 460     {
 461         // retrieve the field affected
 462         Reference< XPropertySet> xColumn( getMatchingColumn( *_pField ) );
 463         // and normalize it's content
 464         if ( xColumn.is() )
 465         {
 466             OUString sText( _pField->GetText() );
 467             m_aPredicateInput.normalizePredicateString( sText, xColumn );
 468             _pField->SetText( sText );
 469         }
 470     }
 471
 472     return 0L;
 473 }
 474
 475 void DlgFilterCrit::SetLine( sal_uInt16 nIdx,const PropertyValue& _rItem,bool _bOr  )
 476 {
 477     OUString aCondition;
 478     _rItem.Value >>= aCondition;
 479     OUString aStr = aCondition;
 480     if ( _rItem.Handle == SQLFilterOperator::LIKE ||
 481          _rItem.Handle == SQLFilterOperator::NOT_LIKE )
 482         ::Replace_SQL_PlaceHolder(aStr);
 483     aStr = comphelper::string::stripEnd(aStr, ' ');
 484
 485     Reference< XPropertySet > xColumn = getColumn( _rItem.Name );
 486
 487     // remove the predicate from the condition
 488     switch(_rItem.Handle)
 489     {
 490         case SQLFilterOperator::EQUAL:
 491             //  aStr.Erase(0,1);
 492             break;
 493         case SQLFilterOperator::NOT_EQUAL:
 494             aStr = aStr.copy(2);
 495             break;
 496         case SQLFilterOperator::LESS:
 497             aStr = aStr.copy(1);
 498             break;
 499         case SQLFilterOperator::LESS_EQUAL:
 500             aStr = aStr.copy(2);
 501             break;
 502         case SQLFilterOperator::GREATER:
 503             aStr = aStr.copy(1);
 504             break;
 505         case SQLFilterOperator::GREATER_EQUAL:
 506             aStr = aStr.copy(2);
 507             break;
 508         case SQLFilterOperator::NOT_LIKE:
 509             aStr = aStr.copy(8);
 510             break;
 511         case SQLFilterOperator::LIKE:
 512             aStr = aStr.copy(4);
 513             break;
 514         case SQLFilterOperator::SQLNULL:
 515             aStr = aStr.copy(7);
 516             break;
 517         case SQLFilterOperator::NOT_SQLNULL:
 518             aStr = aStr.copy(11);
 519             break;
 520     }
 521     aStr = comphelper::string::stripStart(aStr, ' ');
 522
 523     // to make sure that we only set first three
 524     ListBox* pColumnListControl =  NULL;
 525     ListBox* pPredicateListControl = NULL;
 526     Edit* pPredicateValueControl = NULL;
 527     switch( nIdx )
 528     {
 529         case 0:
 530             pColumnListControl = m_pLB_WHEREFIELD1;
 531             pPredicateListControl = m_pLB_WHERECOMP1;
 532             pPredicateValueControl = m_pET_WHEREVALUE1;
 533             break;
 534         case 1:
 535             m_pLB_WHERECOND2->SelectEntryPos( _bOr ? 1 : 0 );
 536
 537             pColumnListControl = m_pLB_WHEREFIELD2;
 538             pPredicateListControl = m_pLB_WHERECOMP2;
 539             pPredicateValueControl = m_pET_WHEREVALUE2;
 540             break;
 541         case 2:
 542             m_pLB_WHERECOND3->SelectEntryPos( _bOr ? 1 : 0 );
 543
 544             pColumnListControl = m_pLB_WHEREFIELD3;
 545             pPredicateListControl = m_pLB_WHERECOMP3;
 546             pPredicateValueControl = m_pET_WHEREVALUE3;
 547             break;
 548     }
 549
 550     if ( pColumnListControl && pPredicateListControl && pPredicateValueControl )
 551     {
 552         OUString sName;
 553         if ( xColumn.is() )
 554             xColumn->getPropertyValue(PROPERTY_NAME) >>= sName;
 555         else
 556             sName = _rItem.Name;
 557         // select the appropriate field name
 558         SelectField( *pColumnListControl, sName );
 559         ListSelectHdl( pColumnListControl );
 560
 561         // select the appropriate condition
 562         pPredicateListControl->SelectEntryPos( GetSelectionPos( (sal_Int32)_rItem.Handle, *pPredicateListControl ) );
 563
 564         // initially normalize this value
 565         OUString aString( aStr );
 566         m_aPredicateInput.normalizePredicateString( aString, xColumn );
 567         pPredicateValueControl->SetText( aString );
 568     }
 569 }
 570
 571 void DlgFilterCrit::SelectField( ListBox& rBox, const OUString& rField )
 572 {
 573     sal_uInt16 nCnt = rBox.GetEntryCount();
 574
 575     for( sal_uInt16 i=0 ; i<nCnt ; i++ )
 576     {
 577         if(rBox.GetEntry(i) == rField)
 578         {
 579             rBox.SelectEntryPos(i);
 580             return;
 581         }
 582     }
 583
 584     rBox.SelectEntryPos(0);
 585 }
 586
 587 void DlgFilterCrit::EnableLines()
 588 {
 589     // enabling/disabling of whole lines
 590     if( LbPos(*m_pLB_WHEREFIELD1) == 0 )
 591     {
 592         m_pLB_WHEREFIELD2->Disable();
 593         m_pLB_WHERECOND2->Disable();
 594         m_pLB_WHERECOMP2->Disable();
 595         m_pET_WHEREVALUE2->Disable();
 596
 597         m_pLB_WHEREFIELD3->Disable();
 598         m_pLB_WHERECOND3->Disable();
 599         m_pLB_WHERECOMP3->Disable();
 600         m_pET_WHEREVALUE3->Disable();
 601     }
 602     else
 603     {
 604         m_pLB_WHEREFIELD2->Enable();
 605         m_pLB_WHERECOND2->Enable();
 606         m_pLB_WHERECOMP2->Enable();
 607         m_pET_WHEREVALUE2->Enable();
 608
 609         m_pLB_WHEREFIELD3->Enable();
 610         m_pLB_WHERECOND3->Enable();
 611         m_pLB_WHERECOMP3->Enable();
 612         m_pET_WHEREVALUE3->Enable();
 613     }
 614
 615     if( LbPos(*m_pLB_WHEREFIELD2) == 0 )
 616     {
 617         m_pLB_WHEREFIELD3->Disable();
 618         m_pLB_WHERECOND3->Disable();
 619         m_pLB_WHERECOMP3->Disable();
 620         m_pET_WHEREVALUE3->Disable();
 621     }
 622     else
 623     {
 624         m_pLB_WHEREFIELD3->Enable();
 625         m_pLB_WHERECOND3->Enable();
 626         m_pLB_WHERECOMP3->Enable();
 627         m_pET_WHEREVALUE3->Enable();
 628     }
 629
 630     // comparison field equal to NOENTRY
 631     if( LbPos(*m_pLB_WHEREFIELD1) == 0 )
 632     {
 633         m_pLB_WHERECOMP1->Disable();
 634         m_pET_WHEREVALUE1->Disable();
 635     }
 636     else
 637     {
 638         m_pLB_WHEREFIELD1->Enable();
 639         m_pLB_WHERECOMP1->Enable();
 640         m_pET_WHEREVALUE1->Enable();
 641     }
 642
 643     if( LbPos(*m_pLB_WHEREFIELD2) == 0 )
 644     {
 645         m_pLB_WHERECOND2->Disable();
 646         m_pLB_WHERECOMP2->Disable();
 647         m_pET_WHEREVALUE2->Disable();
 648     }
 649     else
 650     {
 651         m_pLB_WHERECOND2->Enable();
 652         m_pLB_WHEREFIELD2->Enable();
 653         m_pLB_WHERECOMP2->Enable();
 654         m_pET_WHEREVALUE2->Enable();
 655     }
 656
 657     if( LbPos(*m_pLB_WHEREFIELD3) == 0 )
 658     {
 659         m_pLB_WHERECOND3->Disable();
 660         m_pLB_WHERECOMP3->Disable();
 661         m_pET_WHEREVALUE3->Disable();
 662     }
 663     else
 664     {
 665         m_pLB_WHERECOND3->Enable();
 666         m_pLB_WHERECOND3->Enable();
 667         m_pLB_WHEREFIELD3->Enable();
 668         m_pLB_WHERECOMP3->Enable();
 669         m_pET_WHEREVALUE3->Enable();
 670     }
 671
 672     // comparison operator equal to ISNULL or ISNOTNULL
 673     if(m_pLB_WHERECOMP1->GetEntryCount() > 2 &&
 674         ((LbPos(*m_pLB_WHERECOMP1) == m_pLB_WHERECOMP1->GetEntryCount()-1) ||
 675          (LbPos(*m_pLB_WHERECOMP1) == m_pLB_WHERECOMP1->GetEntryCount()-2)) )
 676         m_pET_WHEREVALUE1->Disable();
 677
 678     if(m_pLB_WHERECOMP2->GetEntryCount() > 2 &&
 679         ((LbPos(*m_pLB_WHERECOMP2) == m_pLB_WHERECOMP2->GetEntryCount()-1) ||
 680          (LbPos(*m_pLB_WHERECOMP2) == m_pLB_WHERECOMP2->GetEntryCount()-2)) )
 681         m_pET_WHEREVALUE2->Disable();
 682
 683     if(m_pLB_WHERECOMP3->GetEntryCount() > 2 &&
 684         ((LbPos(*m_pLB_WHERECOMP3) == m_pLB_WHERECOMP3->GetEntryCount()-1) ||
 685          (LbPos(*m_pLB_WHERECOMP3) == m_pLB_WHERECOMP3->GetEntryCount()-2)) )
 686         m_pET_WHEREVALUE3->Disable();
 687 }
 688
 689 IMPL_LINK( DlgFilterCrit, ListSelectHdl, ListBox *, pListBox )
 690 {
 691     OUString aName;
 692     ListBox* pComp;
 693     if(pListBox == m_pLB_WHEREFIELD1)
 694     {
 695         aName = LbText(*m_pLB_WHEREFIELD1);
 696         pComp = m_pLB_WHERECOMP1;
 697     }
 698     else if(pListBox == m_pLB_WHEREFIELD2)
 699     {
 700         aName = LbText(*m_pLB_WHEREFIELD2);
 701         pComp = m_pLB_WHERECOMP2;
 702     }
 703     else
 704     {
 705         aName = LbText(*m_pLB_WHEREFIELD3);
 706         pComp = m_pLB_WHERECOMP3;
 707     }
 708
 709     pComp->Clear();
 710
 711     Reference<XPropertySet> xColumn = getColumn(aName);
 712     if ( xColumn.is() )
 713     {
 714         sal_Int32 nDataType = 0;
 715         xColumn->getPropertyValue(PROPERTY_TYPE) >>= nDataType;
 716         sal_Int32 eColumnSearch = dbtools::getSearchColumnFlag(m_xConnection,nDataType);
 717
 718         if(eColumnSearch  == ColumnSearch::FULL)
 719         {
 720             for(sal_Int32 i=0;i < comphelper::string::getTokenCount(m_aSTR_COMPARE_OPERATORS, ';');i++)
 721                 pComp->InsertEntry(m_aSTR_COMPARE_OPERATORS.getToken(i, ';'));
 722         }
 723         else if(eColumnSearch == ColumnSearch::CHAR)
 724         {
 725             for(sal_Int32 i=6; i<10; i++)
 726                 pComp->InsertEntry(m_aSTR_COMPARE_OPERATORS.getToken(i, ';'));
 727         }
 728         else if(eColumnSearch == ColumnSearch::BASIC)
 729         {
 730             sal_Int32 i;
 731             for( i = 0; i < 6; i++ )
 732                 pComp->InsertEntry(m_aSTR_COMPARE_OPERATORS.getToken(i, ';'));
 733             for(i=8; i < comphelper::string::getTokenCount(m_aSTR_COMPARE_OPERATORS, ';'); ++i)
 734                 pComp->InsertEntry(m_aSTR_COMPARE_OPERATORS.getToken(i, ';'));
 735         }
 736         else
 737         {
 738             OSL_FAIL("DlgFilterCrit::ListSelectHdl: This column should not exist at all.");
 739         }
 740     }
 741     pComp->SelectEntryPos(0);
 742
 743     EnableLines();
 744     return 0;
 745 }
 746
 747 IMPL_LINK( DlgFilterCrit, ListSelectCompHdl, ListBox *, /*pListBox*/ )
 748 {
 749     EnableLines();
 750     return 0;
 751 }
 752
 753 void DlgFilterCrit::BuildWherePart()
 754 {
 755     Sequence<Sequence<PropertyValue> > aFilter,aHaving;
 756     aFilter.realloc(1);
 757     aHaving.realloc(1);
 758
 759     if( LbPos(*m_pLB_WHEREFIELD1) != 0 )
 760     {
 761         PropertyValue aValue;
 762         if ( getCondition(*m_pLB_WHEREFIELD1,*m_pLB_WHERECOMP1,*m_pET_WHEREVALUE1,aValue) )
 763         {
 764             aHaving[0].realloc(1);
 765             aHaving[0][0] = aValue;
 766         }
 767         else
 768         {
 769             aFilter[0].realloc(1);
 770             aFilter[0][0] = aValue;
 771         }
 772     }
 773
 774     if( LbPos(*m_pLB_WHEREFIELD2) != 0 )
 775     {
 776         PropertyValue aValue;
 777         Sequence<Sequence<PropertyValue> >& _rValues = aFilter;
 778         if ( getCondition(*m_pLB_WHEREFIELD2,*m_pLB_WHERECOMP2,*m_pET_WHEREVALUE2,aValue) )
 779             _rValues = aHaving;
 780         PropertyValue* pPos = NULL;
 781         if ( m_pLB_WHERECOND2->GetSelectEntryPos() )
 782         {
 783             sal_Int32 nPos = _rValues.getLength();
 784             _rValues.realloc( nPos + 1);
 785             _rValues[nPos].realloc( 1);
 786             pPos = &_rValues[nPos][0];
 787         }
 788         else
 789         {
 790             sal_Int32 nPos = _rValues.getLength() - 1;
 791             sal_Int32 nAndPos = _rValues[nPos].getLength();
 792             _rValues[nPos].realloc( _rValues[nPos].getLength() + 1);
 793             pPos = &_rValues[nPos][nAndPos];
 794         }
 795         *pPos = aValue;
 796     }
 797
 798     if( LbPos(*m_pLB_WHEREFIELD3) != 0 )
 799     {
 800         PropertyValue aValue;
 801         Sequence<Sequence<PropertyValue> >& _rValues = aFilter;
 802         if ( getCondition(*m_pLB_WHEREFIELD3,*m_pLB_WHERECOMP3,*m_pET_WHEREVALUE3,aValue) )
 803             _rValues = aHaving;
 804         PropertyValue* pPos = NULL;
 805         if ( m_pLB_WHERECOND3->GetSelectEntryPos() )
 806         {
 807             sal_Int32 nPos = _rValues.getLength();
 808             _rValues.realloc( nPos + 1);
 809             _rValues[nPos].realloc( 1);
 810             pPos = &_rValues[nPos][0];
 811         }
 812         else
 813         {
 814             sal_Int32 nPos = _rValues.getLength() - 1;
 815             sal_Int32 nAndPos = _rValues[nPos].getLength();
 816             _rValues[nPos].realloc( _rValues[nPos].getLength() + 1);
 817             pPos = &_rValues[nPos][nAndPos];
 818         }
 819         *pPos = aValue;
 820     }
 821     try
 822     {
 823         m_xQueryComposer->setStructuredFilter(aFilter);
 824         m_xQueryComposer->setStructuredHavingClause(aHaving);
 825     }
 826     catch(const Exception&)
 827     {
 828         DBG_UNHANDLED_EXCEPTION();
 829     }
 830 }
 831
 832 void DlgFilterCrit::fillLines(const Sequence<Sequence<PropertyValue > >& _aValues)
 833 {
 834     const Sequence<PropertyValue >* pOrIter = _aValues.getConstArray();
 835     const Sequence<PropertyValue >* pOrEnd   = pOrIter + _aValues.getLength();
 836     for(sal_uInt16 i=0;pOrIter != pOrEnd; ++pOrIter)
 837     {
 838         bool bOr = true;
 839         const PropertyValue* pAndIter   = pOrIter->getConstArray();
 840         const PropertyValue* pAndEnd    = pAndIter + pOrIter->getLength();
 841         for(;pAndIter != pAndEnd; ++pAndIter)
 842         {
 843             SetLine( i++,*pAndIter,bOr);
 844             bOr = false;
 845         }
 846     }
 847 }
 848
 849 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */