LCOV - code coverage report
Current view: top level - libreoffice/dbaccess/source/ui/querydesign - SelectionBrowseBox.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 1473 0.0 %
Date: 2012-12-27 Functions: 0 97 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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 "SelectionBrowseBox.hxx"
      21             : #include <com/sun/star/sdbc/XDatabaseMetaData.hpp>
      22             : #include <com/sun/star/sdbc/DataType.hpp>
      23             : #include "QueryDesignView.hxx"
      24             : #include "querycontroller.hxx"
      25             : #include "QueryTableView.hxx"
      26             : #include "browserids.hxx"
      27             : #include <comphelper/extract.hxx>
      28             : #include <comphelper/stl_types.hxx>
      29             : #include <comphelper/string.hxx>
      30             : #include <comphelper/types.hxx>
      31             : #include "TableFieldInfo.hxx"
      32             : #include "dbu_qry.hrc"
      33             : #include "dbaccess_helpid.hrc"
      34             : #include <com/sun/star/container/XNameAccess.hpp>
      35             : #include "dbustrings.hrc"
      36             : #include "QTableWindow.hxx"
      37             : #include <vcl/msgbox.hxx>
      38             : #include "QueryDesignFieldUndoAct.hxx"
      39             : #include "sqlmessage.hxx"
      40             : #include "UITools.hxx"
      41             : #include <osl/diagnose.h>
      42             : #include "svtools/treelistentry.hxx"
      43             : 
      44             : using namespace ::svt;
      45             : using namespace ::dbaui;
      46             : using namespace ::connectivity;
      47             : using namespace ::com::sun::star::uno;
      48             : using namespace ::com::sun::star::sdbc;
      49             : using namespace ::com::sun::star::beans;
      50             : using namespace ::com::sun::star::container;
      51             : using namespace ::com::sun::star::util;
      52             : using namespace ::com::sun::star::accessibility;
      53             : 
      54             : #define g_strOne rtl::OUString("1")
      55             : #define g_strZero rtl::OUString("0")
      56             : 
      57             : #define DEFAULT_QUERY_COLS  20
      58             : #define DEFAULT_SIZE        GetTextWidth(g_strZero) * 30
      59             : #define CHECKBOX_SIZE       10
      60             : #define HANDLE_ID            0
      61             : #define HANDLE_COLUMN_WITDH 70
      62             : #define SORT_COLUMN_NONE    0xFFFFFFFF
      63             : 
      64             : // -----------------------------------------------------------------------------
      65             : namespace
      66             : {
      67           0 :     sal_Bool isFieldNameAsterix(const ::rtl::OUString& _sFieldName )
      68             :     {
      69           0 :         sal_Bool bAsterix = !(!_sFieldName.isEmpty() && _sFieldName.toChar() != '*');
      70           0 :         if ( !bAsterix )
      71             :         {
      72           0 :             String sName = _sFieldName;
      73           0 :             xub_StrLen nTokenCount = comphelper::string::getTokenCount(sName, '.');
      74           0 :             if (    (nTokenCount == 2 && sName.GetToken(1,'.').GetChar(0) == '*' )
      75           0 :                 ||  (nTokenCount == 3 && sName.GetToken(2,'.').GetChar(0) == '*' ) )
      76             :             {
      77           0 :                 bAsterix = sal_True;
      78           0 :             }
      79             :         }
      80           0 :         return bAsterix;
      81             :     }
      82             :     // -----------------------------------------------------------------------------
      83           0 :     sal_Bool lcl_SupportsCoreSQLGrammar(const Reference< XConnection>& _xConnection)
      84             :     {
      85           0 :         sal_Bool bSupportsCoreGrammar = sal_False;
      86           0 :         if ( _xConnection.is() )
      87             :         {
      88             :             try
      89             :             {
      90           0 :                 Reference< XDatabaseMetaData >  xMetaData = _xConnection->getMetaData();
      91           0 :                 bSupportsCoreGrammar = xMetaData.is() && xMetaData->supportsCoreSQLGrammar();
      92             :             }
      93           0 :             catch(Exception&)
      94             :             {
      95             :             }
      96             :         }
      97           0 :         return bSupportsCoreGrammar;
      98             :     }
      99             : }
     100             : 
     101             : DBG_NAME(OSelectionBrowseBox)
     102             : //------------------------------------------------------------------------------
     103           0 : OSelectionBrowseBox::OSelectionBrowseBox( Window* pParent )
     104             :                    :EditBrowseBox( pParent,EBBF_NOROWPICTURE, WB_3DLOOK, BROWSER_COLUMNSELECTION | BROWSER_KEEPSELECTION |  BROWSER_HIDESELECT |
     105             :                                   BROWSER_HIDECURSOR | BROWSER_HLINESFULL | BROWSER_VLINESFULL )
     106             :                    ,m_aFunctionStrings(ModuleRes(STR_QUERY_FUNCTIONS))
     107             :                    ,m_nVisibleCount(0)
     108             :                    ,m_nLastSortColumn(SORT_COLUMN_NONE)
     109             :                    ,m_bOrderByUnRelated(sal_True)
     110             :                    ,m_bGroupByUnRelated(sal_True)
     111             :                    ,m_bStopTimer(sal_False)
     112             :                    ,m_bWasEditing(sal_False)
     113             :                    ,m_bDisableErrorBox(sal_False)
     114           0 :                    ,m_bInUndoMode(sal_False)
     115             : {
     116             :     DBG_CTOR(OSelectionBrowseBox,NULL);
     117           0 :     SetHelpId(HID_CTL_QRYDGNCRIT);
     118             : 
     119             :     m_nMode =       BROWSER_COLUMNSELECTION | BROWSER_HIDESELECT
     120             :                 |   BROWSER_KEEPSELECTION   | BROWSER_HIDECURSOR
     121             :                 |   BROWSER_HLINESFULL      | BROWSER_VLINESFULL
     122           0 :                 |   BROWSER_HEADERBAR_NEW   ;
     123             : 
     124           0 :     m_pTextCell     = new Edit(&GetDataWindow(), 0);
     125           0 :     m_pVisibleCell  = new CheckBoxControl(&GetDataWindow());
     126           0 :     m_pTableCell    = new ListBoxControl(&GetDataWindow());     m_pTableCell->SetDropDownLineCount( 20 );
     127           0 :     m_pFieldCell    = new ComboBoxControl(&GetDataWindow());    m_pFieldCell->SetDropDownLineCount( 20 );
     128           0 :     m_pOrderCell    = new ListBoxControl(&GetDataWindow());
     129           0 :     m_pFunctionCell = new ListBoxControl(&GetDataWindow());     m_pFunctionCell->SetDropDownLineCount( 20 );
     130             : 
     131           0 :     m_pVisibleCell->SetHelpId(HID_QRYDGN_ROW_VISIBLE);
     132           0 :     m_pTableCell->SetHelpId(HID_QRYDGN_ROW_TABLE);
     133           0 :     m_pFieldCell->SetHelpId(HID_QRYDGN_ROW_FIELD);
     134           0 :     m_pOrderCell->SetHelpId(HID_QRYDGN_ROW_ORDER);
     135           0 :     m_pFunctionCell->SetHelpId(HID_QRYDGN_ROW_FUNCTION);
     136             : 
     137             :     //////////////////////////////////////////////////////////////////////
     138             :     // TriState der ::com::sun::star::form::CheckBox abschalten
     139           0 :     m_pVisibleCell->GetBox().EnableTriState( sal_False );
     140             : 
     141           0 :     Font aTitleFont = OutputDevice::GetDefaultFont( DEFAULTFONT_SANS_UNICODE,Window::GetSettings().GetLanguageTag().getLanguageType(),DEFAULTFONT_FLAGS_ONLYONE);
     142           0 :     aTitleFont.SetSize(Size(0, 6));
     143           0 :     SetTitleFont(aTitleFont);
     144             : 
     145           0 :     String aTxt(ModuleRes(STR_QUERY_SORTTEXT));
     146           0 :     xub_StrLen nCount = comphelper::string::getTokenCount(aTxt, ';');
     147           0 :     xub_StrLen nIdx = 0;
     148           0 :     for (; nIdx < nCount; nIdx++)
     149           0 :         m_pOrderCell->InsertEntry(aTxt.GetToken(nIdx));
     150             : 
     151           0 :     for(long i=0;i < BROW_ROW_CNT;i++)
     152           0 :         m_bVisibleRow.push_back(sal_True);
     153             : 
     154           0 :     m_bVisibleRow[BROW_FUNCTION_ROW] = sal_False;   // zuerst ausblenden
     155             : 
     156           0 :     m_timerInvalidate.SetTimeout(200);
     157           0 :     m_timerInvalidate.SetTimeoutHdl(LINK(this, OSelectionBrowseBox, OnInvalidateTimer));
     158           0 :     m_timerInvalidate.Start();
     159           0 : }
     160             : 
     161             : //------------------------------------------------------------------------------
     162           0 : OSelectionBrowseBox::~OSelectionBrowseBox()
     163             : {
     164             :     DBG_DTOR(OSelectionBrowseBox,NULL);
     165             : 
     166           0 :     delete m_pTextCell;
     167           0 :     delete m_pVisibleCell;
     168           0 :     delete m_pFieldCell;
     169           0 :     delete m_pTableCell;
     170           0 :     delete m_pOrderCell;
     171           0 :     delete m_pFunctionCell;
     172           0 : }
     173             : // -----------------------------------------------------------------------------
     174           0 : void OSelectionBrowseBox::initialize()
     175             : {
     176           0 :     Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
     177           0 :     if(xConnection.is())
     178             :     {
     179           0 :         const IParseContext& rContext = static_cast<OQueryController&>(getDesignView()->getController()).getParser().getContext();
     180             :         IParseContext::InternationalKeyCode eFunctions[] = { IParseContext::KEY_AVG,IParseContext::KEY_COUNT,IParseContext::KEY_MAX
     181             :             ,IParseContext::KEY_MIN,IParseContext::KEY_SUM
     182             :             ,IParseContext::KEY_EVERY
     183             :             ,IParseContext::KEY_ANY
     184             :             ,IParseContext::KEY_SOME
     185             :             ,IParseContext::KEY_STDDEV_POP
     186             :             ,IParseContext::KEY_STDDEV_SAMP
     187             :             ,IParseContext::KEY_VAR_SAMP
     188             :             ,IParseContext::KEY_VAR_POP
     189             :             ,IParseContext::KEY_COLLECT
     190             :             ,IParseContext::KEY_FUSION
     191             :             ,IParseContext::KEY_INTERSECTION
     192           0 :         };
     193             : 
     194           0 :         String sGroup = m_aFunctionStrings.GetToken(comphelper::string::getTokenCount(m_aFunctionStrings, ';') - 1);
     195           0 :         m_aFunctionStrings = m_aFunctionStrings.GetToken(0);
     196             : 
     197           0 :         for (size_t i = 0; i < sizeof (eFunctions) / sizeof (eFunctions[0]); ++i)
     198             :         {
     199           0 :             m_aFunctionStrings += String(RTL_CONSTASCII_USTRINGPARAM(";"));
     200           0 :             m_aFunctionStrings += rtl::OStringToOUString(rContext.getIntlKeywordAscii(eFunctions[i]),
     201           0 :                 RTL_TEXTENCODING_UTF8);
     202             :         }
     203           0 :         m_aFunctionStrings += String(RTL_CONSTASCII_USTRINGPARAM(";"));
     204           0 :         m_aFunctionStrings += sGroup;
     205             : 
     206             :         // Aggregate functions in general available only with Core SQL
     207             :         // We slip in a few optionals one, too.
     208           0 :         if ( lcl_SupportsCoreSQLGrammar(xConnection) )
     209             :         {
     210           0 :             xub_StrLen nCount = comphelper::string::getTokenCount(m_aFunctionStrings, ';');
     211           0 :             for (xub_StrLen nIdx = 0; nIdx < nCount; nIdx++)
     212           0 :                 m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(nIdx));
     213             :         }
     214             :         else // else only COUNT(*) and COUNT("table".*)
     215             :         {
     216           0 :             m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(0));
     217           0 :             m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(2)); // 2 -> COUNT
     218             :         }
     219             :         try
     220             :         {
     221           0 :             Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
     222           0 :             if ( xMetaData.is() )
     223             :             {
     224           0 :                 m_bOrderByUnRelated = xMetaData->supportsOrderByUnrelated();
     225           0 :                 m_bGroupByUnRelated = xMetaData->supportsGroupByUnrelated();
     226           0 :             }
     227             :         }
     228           0 :         catch(Exception&)
     229             :         {
     230           0 :         }
     231             :     }
     232             : 
     233           0 :     Init();
     234           0 : }
     235             : //==============================================================================
     236           0 : OQueryDesignView* OSelectionBrowseBox::getDesignView()
     237             : {
     238             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
     239             :     OSL_ENSURE(static_cast<const OQueryDesignView*>(GetParent()),"Parent isn't an OQueryDesignView!");
     240           0 :     return static_cast<OQueryDesignView*>(GetParent());
     241             : }
     242             : // -----------------------------------------------------------------------------
     243           0 : OQueryDesignView* OSelectionBrowseBox::getDesignView() const
     244             : {
     245             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
     246             :     OSL_ENSURE(static_cast<const OQueryDesignView*>(GetParent()),"Parent isn't an OQueryDesignView!");
     247           0 :     return static_cast<OQueryDesignView*>(GetParent());
     248             : }
     249             : namespace
     250             : {
     251           0 :     class OSelectionBrwBoxHeader : public ::svt::EditBrowserHeader
     252             :     {
     253             :         OSelectionBrowseBox* m_pBrowseBox;
     254             :     protected:
     255             :         virtual void Select();
     256             :     public:
     257             :         OSelectionBrwBoxHeader(OSelectionBrowseBox* pParent);
     258             :     };
     259           0 :     OSelectionBrwBoxHeader::OSelectionBrwBoxHeader(OSelectionBrowseBox* pParent)
     260             :         : ::svt::EditBrowserHeader(pParent,WB_BUTTONSTYLE|WB_DRAG)
     261           0 :         ,m_pBrowseBox(pParent)
     262             :     {
     263           0 :     }
     264             : 
     265           0 :     void OSelectionBrwBoxHeader::Select()
     266             :     {
     267           0 :         EditBrowserHeader::Select();
     268           0 :         m_pBrowseBox->GrabFocus();
     269             : 
     270           0 :         BrowserMode nMode = m_pBrowseBox->GetMode();
     271           0 :         if ( 0 == m_pBrowseBox->GetSelectColumnCount() )
     272             :         {
     273           0 :             m_pBrowseBox->DeactivateCell();
     274             :             // wenn es schon eine selektierte Spalte gibt, bin ich schon im richtigen Modus
     275           0 :             if ( BROWSER_HIDESELECT == ( nMode & BROWSER_HIDESELECT ) )
     276             :             {
     277           0 :                 nMode &= ~BROWSER_HIDESELECT;
     278           0 :                 nMode |= BROWSER_MULTISELECTION;
     279           0 :                 m_pBrowseBox->SetMode( nMode );
     280             :             }
     281             :         }
     282           0 :         m_pBrowseBox->SelectColumnId( GetCurItemId() );
     283           0 :         m_pBrowseBox->DeactivateCell();
     284           0 :     }
     285             : }
     286             : 
     287             : // -----------------------------------------------------------------------------
     288           0 : BrowserHeader* OSelectionBrowseBox::imp_CreateHeaderBar(BrowseBox* /*pParent*/)
     289             : {
     290           0 :     return new OSelectionBrwBoxHeader(this);
     291             : }
     292             : // -----------------------------------------------------------------------------
     293           0 : void OSelectionBrowseBox::ColumnMoved( sal_uInt16 nColId,sal_Bool _bCreateUndo )
     294             : {
     295           0 :     EditBrowseBox::ColumnMoved( nColId );
     296             :     // swap the two columns
     297           0 :     sal_uInt16 nNewPos = GetColumnPos( nColId );
     298           0 :     OTableFields& rFields = getFields();
     299           0 :     if ( rFields.size() > sal_uInt16(nNewPos-1) )
     300             :     {
     301           0 :         sal_uInt16 nOldPos = 0;
     302           0 :         OTableFields::iterator aEnd = rFields.end();
     303           0 :         OTableFields::iterator aIter = rFields.begin();
     304           0 :         for (; aIter != aEnd && ( (*aIter)->GetColumnId() != nColId ); ++aIter,++nOldPos)
     305             :             ;
     306             : 
     307             :         OSL_ENSURE( (nNewPos-1) != nOldPos && nOldPos < rFields.size(),"Old and new position are equal!");
     308           0 :         if ( aIter != aEnd )
     309             :         {
     310           0 :             OTableFieldDescRef pOldEntry = rFields[nOldPos];
     311           0 :             rFields.erase(rFields.begin() + nOldPos);
     312           0 :             rFields.insert(rFields.begin() + nNewPos - 1,pOldEntry);
     313             : 
     314             :             // create the undo action
     315           0 :             if ( !m_bInUndoMode && _bCreateUndo )
     316             :             {
     317           0 :                 OTabFieldMovedUndoAct* pUndoAct = new OTabFieldMovedUndoAct(this);
     318           0 :                 pUndoAct->SetColumnPosition( nOldPos + 1);
     319           0 :                 pUndoAct->SetTabFieldDescr(pOldEntry);
     320             : 
     321           0 :                 getDesignView()->getController().addUndoActionAndInvalidate(pUndoAct);
     322           0 :             }
     323             :         }
     324             :     }
     325             :     else
     326             :         OSL_FAIL("Invalid column id!");
     327           0 : }
     328             : //------------------------------------------------------------------------------
     329           0 : void OSelectionBrowseBox::Init()
     330             : {
     331             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
     332             : 
     333           0 :     EditBrowseBox::Init();
     334             : 
     335             :     // set the header bar
     336           0 :     BrowserHeader* pNewHeaderBar = CreateHeaderBar(this);
     337           0 :     pNewHeaderBar->SetMouseTransparent(sal_False);
     338             : 
     339           0 :     SetHeaderBar(pNewHeaderBar);
     340           0 :     SetMode(m_nMode);
     341             : 
     342           0 :     Font    aFont( GetDataWindow().GetFont() );
     343           0 :     aFont.SetWeight( WEIGHT_NORMAL );
     344           0 :     GetDataWindow().SetFont( aFont );
     345             : 
     346           0 :     Size aHeight;
     347           0 :     const Control* pControls[] = { m_pTextCell,m_pVisibleCell,m_pTableCell,m_pFieldCell };
     348             : 
     349           0 :     for (sal_Size i = 0; i < sizeof (pControls) / sizeof (pControls[0]); ++i)
     350             :     {
     351           0 :         const Size aTemp( pControls[i]->GetOptimalSize(WINDOWSIZE_PREFERRED) );
     352           0 :         if ( aTemp.Height() > aHeight.Height() )
     353           0 :             aHeight.Height() = aTemp.Height();
     354             :     }
     355           0 :     SetDataRowHeight(aHeight.Height());
     356           0 :     SetTitleLines(1);
     357             :     // Anzahl der sichtbaren Zeilen ermitteln
     358           0 :     for(long i=0;i<BROW_ROW_CNT;i++)
     359             :     {
     360           0 :         if(m_bVisibleRow[i])
     361           0 :             m_nVisibleCount++;
     362             :     }
     363           0 :     RowInserted(0, m_nVisibleCount, sal_False);
     364             :     try
     365             :     {
     366           0 :         Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
     367           0 :         if(xConnection.is())
     368             :         {
     369           0 :             Reference< XDatabaseMetaData >  xMetaData = xConnection->getMetaData();
     370           0 :             m_nMaxColumns = xMetaData.is() ? xMetaData->getMaxColumnsInSelect() : 0;
     371             : 
     372             :         }
     373             :         else
     374           0 :             m_nMaxColumns = 0;
     375             :     }
     376           0 :     catch(const SQLException&)
     377             :     {
     378             :         OSL_FAIL("Catched Exception when asking for database metadata options!");
     379           0 :         m_nMaxColumns = 0;
     380           0 :     }
     381           0 : }
     382             : 
     383             : //------------------------------------------------------------------------------
     384           0 : void OSelectionBrowseBox::PreFill()
     385             : {
     386             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
     387           0 :     SetUpdateMode(sal_False);
     388             : 
     389           0 :     if (GetCurRow() != 0)
     390           0 :         GoToRow(0);
     391             : 
     392             : 
     393           0 :     static_cast< OQueryController& >( getDesignView()->getController() ).clearFields();
     394             : 
     395           0 :     DeactivateCell();
     396             : 
     397           0 :     RemoveColumns();
     398           0 :     InsertHandleColumn( HANDLE_COLUMN_WITDH );
     399           0 :     SetUpdateMode(sal_True);
     400           0 : }
     401             : //------------------------------------------------------------------------------
     402           0 : void OSelectionBrowseBox::ClearAll()
     403             : {
     404             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
     405           0 :     SetUpdateMode(sal_False);
     406             : 
     407           0 :     OTableFields::reverse_iterator aIter = getFields().rbegin();
     408           0 :     for ( ;aIter != getFields().rend(); ++aIter )
     409             :     {
     410           0 :         if ( !(*aIter)->IsEmpty() )
     411             :         {
     412           0 :             RemoveField( (*aIter)->GetColumnId() );
     413           0 :             aIter = getFields().rbegin();
     414             :         }
     415             :     }
     416           0 :     m_nLastSortColumn = SORT_COLUMN_NONE;
     417           0 :     SetUpdateMode(sal_True);
     418           0 : }
     419             : //------------------------------------------------------------------------------
     420           0 : void OSelectionBrowseBox::SetReadOnly(sal_Bool bRO)
     421             : {
     422           0 :     if (bRO)
     423             :     {
     424           0 :         DeactivateCell();
     425           0 :         m_nMode &= ~BROWSER_HIDECURSOR;
     426           0 :         SetMode(m_nMode);
     427             :     }
     428             :     else
     429             :     {
     430           0 :         m_nMode |= BROWSER_HIDECURSOR;
     431           0 :         SetMode(m_nMode);
     432           0 :         ActivateCell();
     433             :     }
     434           0 : }
     435             : 
     436             : //------------------------------------------------------------------------------
     437           0 : CellController* OSelectionBrowseBox::GetController(long nRow, sal_uInt16 nColId)
     438             : {
     439             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
     440           0 :     if ( nColId > getFields().size() )
     441           0 :         return NULL;
     442           0 :     OTableFieldDescRef pEntry = getFields()[nColId-1];
     443             :     OSL_ENSURE(pEntry.is(), "OSelectionBrowseBox::GetController : keine FieldDescription !");
     444             : 
     445           0 :     if (!pEntry.is())
     446           0 :         return NULL;
     447             : 
     448           0 :     if (static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly())
     449           0 :         return NULL;
     450             : 
     451           0 :     long nCellIndex = GetRealRow(nRow);
     452           0 :     switch (nCellIndex)
     453             :     {
     454             :         case BROW_FIELD_ROW:
     455           0 :             return new ComboBoxCellController(m_pFieldCell);
     456             :         case BROW_TABLE_ROW:
     457           0 :             return new ListBoxCellController(m_pTableCell);
     458             :         case BROW_VIS_ROW:
     459           0 :             return new CheckBoxCellController(m_pVisibleCell);
     460             :         case BROW_ORDER_ROW:
     461           0 :             return new ListBoxCellController(m_pOrderCell);
     462             :         case BROW_FUNCTION_ROW:
     463           0 :             return new ListBoxCellController(m_pFunctionCell);
     464             :         default:
     465           0 :             return new EditCellController(m_pTextCell);
     466           0 :     }
     467             : }
     468             : 
     469             : //------------------------------------------------------------------------------
     470           0 : void OSelectionBrowseBox::InitController(CellControllerRef& /*rController*/, long nRow, sal_uInt16 nColId)
     471             : {
     472             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
     473             :     OSL_ENSURE(nColId != BROWSER_INVALIDID,"An Invalid Id was set!");
     474           0 :     if ( nColId == BROWSER_INVALIDID )
     475             :         return;
     476           0 :     sal_uInt16 nPos = GetColumnPos(nColId);
     477           0 :     if ( nPos == 0 || nPos == BROWSER_INVALIDID || nPos > getFields().size() )
     478             :         return;
     479           0 :     OTableFieldDescRef pEntry = getFields()[nPos-1];
     480             :     OSL_ENSURE(pEntry.is(), "OSelectionBrowseBox::InitController : keine FieldDescription !");
     481           0 :     long nCellIndex = GetRealRow(nRow);
     482             : 
     483           0 :     switch (nCellIndex)
     484             :     {
     485             :         case BROW_FIELD_ROW:
     486             :         {
     487           0 :             m_pFieldCell->Clear();
     488           0 :             m_pFieldCell->SetText(String());
     489             : 
     490           0 :             String aField(pEntry->GetField());
     491           0 :             String aTable(pEntry->GetAlias());
     492             : 
     493           0 :             getDesignView()->fillValidFields(aTable, m_pFieldCell);
     494             : 
     495             :             // * durch alias.* ersetzen
     496           0 :             if ((aField.GetChar(0) == '*') && aTable.Len())
     497             :             {
     498           0 :                 aField = aTable;
     499           0 :                 aField.AppendAscii(".*");
     500             :             }
     501           0 :             m_pFieldCell->SetText(aField);
     502           0 :         }   break;
     503             :         case BROW_TABLE_ROW:
     504             :         {
     505           0 :             m_pTableCell->Clear();
     506           0 :             enableControl(pEntry,m_pTableCell);
     507           0 :             if ( !pEntry->isCondition() )
     508             :             {
     509           0 :                 OJoinTableView::OTableWindowMap* pTabWinList = getDesignView()->getTableView()->GetTabWinMap();
     510           0 :                 if (pTabWinList)
     511             :                 {
     512           0 :                     OJoinTableView::OTableWindowMap::iterator aIter = pTabWinList->begin();
     513           0 :                     OJoinTableView::OTableWindowMap::iterator aEnd = pTabWinList->end();
     514             : 
     515           0 :                     for(;aIter != aEnd;++aIter)
     516           0 :                         m_pTableCell->InsertEntry(static_cast<OQueryTableWindow*>(aIter->second)->GetAliasName());
     517             : 
     518           0 :                     m_pTableCell->InsertEntry(String(ModuleRes(STR_QUERY_NOTABLE)), 0);
     519           0 :                     if (!pEntry->GetAlias().isEmpty())
     520           0 :                         m_pTableCell->SelectEntry(pEntry->GetAlias());
     521             :                     else
     522           0 :                         m_pTableCell->SelectEntry(String(ModuleRes(STR_QUERY_NOTABLE)));
     523             :                 }
     524             :             }
     525           0 :         }   break;
     526             :         case BROW_VIS_ROW:
     527             :         {
     528           0 :             m_pVisibleCell->GetBox().Check(pEntry->IsVisible());
     529           0 :             m_pVisibleCell->GetBox().SaveValue();
     530             : 
     531           0 :             enableControl(pEntry,m_pTextCell);
     532             : 
     533           0 :             if(!pEntry->IsVisible() && pEntry->GetOrderDir() != ORDER_NONE && !m_bOrderByUnRelated)
     534             :             {
     535             :                 // Spalte muss sichtbar sein, um im ORDER BY aufzutauchen
     536           0 :                 pEntry->SetVisible(sal_True);
     537           0 :                 m_pVisibleCell->GetBox().Check(pEntry->IsVisible());
     538           0 :                 m_pVisibleCell->GetBox().SaveValue();
     539           0 :                 m_pVisibleCell->GetBox().Disable();
     540           0 :                 m_pVisibleCell->GetBox().EnableInput(sal_False);
     541           0 :                 String aMessage(ModuleRes(STR_QRY_ORDERBY_UNRELATED));
     542           0 :                 OQueryDesignView* paDView = getDesignView();
     543           0 :                 InfoBox(paDView, aMessage).Execute();
     544             :             }
     545           0 :         }   break;
     546             :         case BROW_ORDER_ROW:
     547             :             m_pOrderCell->SelectEntryPos(
     548           0 :                 sal::static_int_cast< sal_uInt16 >(pEntry->GetOrderDir()));
     549           0 :             enableControl(pEntry,m_pOrderCell);
     550           0 :             break;
     551             :         case BROW_COLUMNALIAS_ROW:
     552           0 :             setTextCellContext(pEntry,pEntry->GetFieldAlias(),HID_QRYDGN_ROW_ALIAS);
     553           0 :             break;
     554             :         case BROW_FUNCTION_ROW:
     555           0 :             setFunctionCell(pEntry);
     556           0 :             break;
     557             :         default:
     558             :         {
     559           0 :             sal_uInt16  nIdx = sal_uInt16(nCellIndex - BROW_CRIT1_ROW);
     560           0 :             setTextCellContext(pEntry,pEntry->GetCriteria( nIdx ),HID_QRYDGN_ROW_CRIT);
     561             :         }
     562             :     }
     563           0 :     Controller()->ClearModified();
     564             : }
     565             : // -----------------------------------------------------------------------------
     566           0 : void OSelectionBrowseBox::notifyTableFieldChanged(const String& _sOldAlias,const String& _sAlias,sal_Bool& _bListAction,sal_uInt16 _nColumnId)
     567             : {
     568           0 :     appendUndoAction(_sOldAlias,_sAlias,BROW_TABLE_ROW,_bListAction);
     569           0 :     if ( m_bVisibleRow[BROW_TABLE_ROW] )
     570           0 :         RowModified(GetBrowseRow(BROW_TABLE_ROW), _nColumnId);
     571           0 : }
     572             : // -----------------------------------------------------------------------------
     573           0 : void OSelectionBrowseBox::notifyFunctionFieldChanged(const String& _sOldFunctionName,const String& _sFunctionName,sal_Bool& _bListAction,sal_uInt16 _nColumnId)
     574             : {
     575           0 :     appendUndoAction(_sOldFunctionName,_sFunctionName,BROW_FUNCTION_ROW,_bListAction);
     576           0 :     if ( !m_bVisibleRow[BROW_FUNCTION_ROW] )
     577           0 :         SetRowVisible(BROW_FUNCTION_ROW, sal_True);
     578           0 :     RowModified(GetBrowseRow(BROW_FUNCTION_ROW), _nColumnId);
     579           0 : }
     580             : // -----------------------------------------------------------------------------
     581           0 : void OSelectionBrowseBox::clearEntryFunctionField(const String& _sFieldName,OTableFieldDescRef& _pEntry,sal_Bool& _bListAction,sal_uInt16 _nColumnId)
     582             : {
     583           0 :     if ( isFieldNameAsterix( _sFieldName ) && (!_pEntry->isNoneFunction() || _pEntry->IsGroupBy()) )
     584             :     {
     585           0 :         String sFunctionName;
     586           0 :         GetFunctionName(SQL_TOKEN_COUNT,sFunctionName);
     587           0 :         String sOldLocalizedFunctionName = _pEntry->GetFunction();
     588           0 :         if ( !sOldLocalizedFunctionName.Equals(sFunctionName) || _pEntry->IsGroupBy() )
     589             :         {
     590             :             // append undo action for the function field
     591           0 :             _pEntry->SetFunctionType(FKT_NONE);
     592           0 :             _pEntry->SetFunction(::rtl::OUString());
     593           0 :             _pEntry->SetGroupBy(sal_False);
     594           0 :             notifyFunctionFieldChanged(sOldLocalizedFunctionName,_pEntry->GetFunction(),_bListAction,_nColumnId);
     595           0 :         }
     596             :     }
     597           0 : }
     598             : // -----------------------------------------------------------------------------
     599           0 : sal_Bool OSelectionBrowseBox::fillColumnRef(const OSQLParseNode* _pColumnRef, const Reference< XConnection >& _rxConnection, OTableFieldDescRef& _pEntry, sal_Bool& _bListAction )
     600             : {
     601             :     OSL_ENSURE(_pColumnRef,"No valid parsenode!");
     602           0 :     ::rtl::OUString sColumnName,sTableRange;
     603           0 :     OSQLParseTreeIterator::getColumnRange(_pColumnRef,_rxConnection,sColumnName,sTableRange);
     604           0 :     return fillColumnRef(sColumnName,sTableRange,_rxConnection->getMetaData(),_pEntry,_bListAction);
     605             : }
     606             : // -----------------------------------------------------------------------------
     607           0 : sal_Bool OSelectionBrowseBox::fillColumnRef(const ::rtl::OUString& _sColumnName,const ::rtl::OUString& _sTableRange,const Reference<XDatabaseMetaData>& _xMetaData,OTableFieldDescRef& _pEntry,sal_Bool& _bListAction)
     608             : {
     609           0 :     sal_Bool bError = sal_False;
     610           0 :     ::comphelper::UStringMixEqual bCase(_xMetaData->supportsMixedCaseQuotedIdentifiers());
     611             :     // check if the table name is the same
     612           0 :     if ( !_sTableRange.isEmpty() && (bCase(_pEntry->GetTable(),_sTableRange) || bCase(_pEntry->GetAlias(),_sTableRange)) )
     613             :     { // a table was already inserted and the tables contains that column name
     614             : 
     615           0 :         if ( !_pEntry->GetTabWindow() )
     616             :         { // fill tab window
     617           0 :             ::rtl::OUString sOldAlias = _pEntry->GetAlias();
     618           0 :             if ( !fillEntryTable(_pEntry,_pEntry->GetTable()) )
     619           0 :                 fillEntryTable(_pEntry,_pEntry->GetAlias()); // only when the first failed
     620           0 :             if ( !bCase(sOldAlias,_pEntry->GetAlias()) )
     621           0 :                 notifyTableFieldChanged(sOldAlias,_pEntry->GetAlias(),_bListAction,GetCurColumnId());
     622             :         }
     623             :     }
     624             :     // check if the table window
     625           0 :     OQueryTableWindow* pEntryTab = static_cast<OQueryTableWindow*>(_pEntry->GetTabWindow());
     626           0 :     if ( !pEntryTab ) // no table found with this name so we have to travel through all tables
     627             :     {
     628           0 :         OJoinTableView::OTableWindowMap* pTabWinList = getDesignView()->getTableView()->GetTabWinMap();
     629           0 :         if ( pTabWinList )
     630             :         {
     631           0 :             sal_uInt16 nTabCount = 0;
     632           0 :             if ( !static_cast<OQueryTableView*>(getDesignView()->getTableView())->FindTableFromField(_sColumnName,_pEntry,nTabCount) ) // error occurred: column not in table window
     633             :             {
     634           0 :                 String sErrorMsg(ModuleRes(RID_STR_FIELD_DOESNT_EXIST));
     635           0 :                 sErrorMsg.SearchAndReplaceAscii("$name$",_sColumnName);
     636           0 :                 OSQLWarningBox( this, sErrorMsg ).Execute();
     637           0 :                 bError = sal_True;
     638             :             }
     639             :             else
     640             :             {
     641           0 :                 pEntryTab = static_cast<OQueryTableWindow*>(_pEntry->GetTabWindow());
     642           0 :                 notifyTableFieldChanged(String(),_pEntry->GetAlias(),_bListAction,GetCurColumnId());
     643             :             }
     644             :         }
     645             :     }
     646           0 :     if ( pEntryTab ) // here we got a valid table
     647           0 :         _pEntry->SetField(_sColumnName);
     648             : 
     649           0 :     return bError;
     650             : }
     651             : // -----------------------------------------------------------------------------
     652           0 : sal_Bool OSelectionBrowseBox::saveField(const String& _sFieldName,OTableFieldDescRef& _pEntry,sal_Bool& _bListAction)
     653             : {
     654           0 :     sal_Bool bError = sal_False;
     655             : 
     656           0 :     OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
     657             : 
     658             :     // first look if the name can be found in our tables
     659           0 :     sal_uInt16 nTabCount = 0;
     660           0 :     String sOldAlias = _pEntry->GetAlias();
     661           0 :     if ( static_cast<OQueryTableView*>(getDesignView()->getTableView())->FindTableFromField(_sFieldName,_pEntry,nTabCount) )
     662             :     {
     663             :         // append undo action for the alias name
     664           0 :         _pEntry->SetField(_sFieldName);
     665           0 :         notifyTableFieldChanged(sOldAlias,_pEntry->GetAlias(),_bListAction,GetCurColumnId());
     666           0 :         clearEntryFunctionField(_sFieldName,_pEntry,_bListAction,_pEntry->GetColumnId());
     667           0 :         return bError;
     668             :     }
     669             : 
     670           0 :     Reference<XConnection> xConnection( rController.getConnection() );
     671           0 :     Reference< XDatabaseMetaData > xMetaData;
     672           0 :     if ( xConnection.is() )
     673           0 :         xMetaData = xConnection->getMetaData();
     674             :     OSL_ENSURE( xMetaData.is(), "OSelectionBrowseBox::saveField: invalid connection/meta data!" );
     675           0 :     if ( !xMetaData.is() )
     676           0 :         return sal_True;
     677             : 
     678           0 :     ::rtl::OUString sErrorMsg;
     679             :     // second test if the name can be set as select columns in a pseudo statement
     680             :     // we have to look which entries  we should quote
     681             : 
     682           0 :     const ::rtl::OUString sFieldAlias = _pEntry->GetFieldAlias();
     683           0 :     size_t nPass = 4;
     684           0 :     ::connectivity::OSQLParser& rParser( rController.getParser() );
     685           0 :     OSQLParseNode* pParseNode = NULL;
     686             :     // 4 passes in trying to interprete the field name
     687             :     // - don't quote the field name, parse internationally
     688             :     // - don't quote the field name, parse en-US
     689             :     // - quote the field name, parse internationally
     690             :     // - quote the field name, parse en-US
     691           0 :     do
     692             :     {
     693           0 :         bool bQuote = ( nPass <= 2 );
     694           0 :         bool bInternational = ( nPass % 2 ) == 0;
     695             : 
     696           0 :         ::rtl::OUString sSql;
     697           0 :         if ( bQuote )
     698           0 :             sSql += ::dbtools::quoteName( xMetaData->getIdentifierQuoteString(), _sFieldName );
     699             :         else
     700           0 :             sSql += _sFieldName;
     701             : 
     702           0 :         if  ( _pEntry->isAggreateFunction() )
     703             :         {
     704             :             OSL_ENSURE(!_pEntry->GetFunction().isEmpty(),"Functionname darf hier nicht leer sein! ;-(");
     705           0 :             ::rtl::OUStringBuffer aTmpStr2( _pEntry->GetFunction());
     706           0 :             aTmpStr2.appendAscii("(");
     707           0 :             aTmpStr2.append(sSql);
     708           0 :             aTmpStr2.appendAscii(")");
     709           0 :             sSql = aTmpStr2.makeStringAndClear();
     710             :         }
     711             : 
     712           0 :         sSql = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SELECT ")) + sSql;
     713           0 :         if ( !sFieldAlias.isEmpty() )
     714             :         { // always quote the alias name there canbe no function in it
     715           0 :             sSql += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" "));
     716           0 :             sSql += ::dbtools::quoteName( xMetaData->getIdentifierQuoteString(), sFieldAlias );
     717             :         }
     718           0 :         sSql += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" FROM x"));
     719             : 
     720           0 :         pParseNode = rParser.parseTree( sErrorMsg, sSql, bInternational );
     721             :     }
     722             :     while ( ( pParseNode == NULL ) && ( --nPass > 0 ) );
     723             : 
     724           0 :     if ( pParseNode == NULL )
     725             :     {
     726             :         // something different which we have to check (may be a select statement)
     727           0 :         String sErrorMessage( ModuleRes( STR_QRY_COLUMN_NOT_FOUND ) );
     728           0 :         sErrorMessage.SearchAndReplaceAscii("$name$",_sFieldName);
     729           0 :         OSQLWarningBox( this, sErrorMessage ).Execute();
     730           0 :         return sal_True;
     731             :     }
     732             : 
     733             :     // we got a valid select column
     734             :     // find what type of column has be inserted
     735           0 :     ::connectivity::OSQLParseNode* pSelection = pParseNode->getChild(2);
     736           0 :     if ( SQL_ISRULE(pSelection,selection) ) // we found the asterix
     737             :     {
     738           0 :         _pEntry->SetField(_sFieldName);
     739           0 :         clearEntryFunctionField(_sFieldName,_pEntry,_bListAction,_pEntry->GetColumnId());
     740             :     } // travel through the select column parse node
     741             :     else
     742             :     {
     743           0 :         ::comphelper::UStringMixEqual bCase(xMetaData->supportsMixedCaseQuotedIdentifiers());
     744             : 
     745           0 :         OTableFieldDescRef aSelEntry = _pEntry;
     746           0 :         sal_uInt16 nColumnId = aSelEntry->GetColumnId();
     747             : 
     748           0 :         sal_uInt32 nCount = pSelection->count();
     749           0 :         for (sal_uInt32 i = 0; i < nCount; ++i)
     750             :         {
     751           0 :             if ( i > 0 ) // may we have to append more than one field
     752             :             {
     753             :                 sal_uInt16 nColumnPostion;
     754           0 :                 aSelEntry = FindFirstFreeCol(nColumnPostion);
     755           0 :                 if ( !aSelEntry.is() )
     756             :                 {
     757           0 :                     AppendNewCol(1);
     758           0 :                     aSelEntry = FindFirstFreeCol(nColumnPostion);
     759             :                 }
     760           0 :                 ++nColumnPostion;
     761           0 :                 nColumnId = GetColumnId(nColumnPostion);
     762             :             }
     763             : 
     764           0 :             ::connectivity::OSQLParseNode* pChild = pSelection->getChild( i );
     765             :             OSL_ENSURE(SQL_ISRULE(pChild,derived_column), "No derived column found!");
     766             :             // get the column alias
     767           0 :             ::rtl::OUString sColumnAlias = OSQLParseTreeIterator::getColumnAlias(pChild);
     768           0 :             if ( !sColumnAlias.isEmpty() ) // we found an as clause
     769             :             {
     770           0 :                 String aSelectionAlias = aSelEntry->GetFieldAlias();
     771           0 :                 aSelEntry->SetFieldAlias( sColumnAlias );
     772             :                 // append undo
     773           0 :                 appendUndoAction(aSelectionAlias,aSelEntry->GetFieldAlias(),BROW_COLUMNALIAS_ROW,_bListAction);
     774           0 :                 if ( m_bVisibleRow[BROW_COLUMNALIAS_ROW] )
     775           0 :                     RowModified(GetBrowseRow(BROW_COLUMNALIAS_ROW), nColumnId);
     776             :             }
     777             : 
     778           0 :             ::connectivity::OSQLParseNode* pColumnRef = pChild->getChild(0);
     779           0 :             if (
     780           0 :                     pColumnRef->count() == 3 &&
     781           0 :                     SQL_ISPUNCTUATION(pColumnRef->getChild(0),"(") &&
     782           0 :                     SQL_ISPUNCTUATION(pColumnRef->getChild(2),")")
     783             :                 )
     784           0 :                 pColumnRef = pColumnRef->getChild(1);
     785             : 
     786           0 :             if ( SQL_ISRULE(pColumnRef,column_ref) ) // we found a valid column name or more column names
     787             :             {
     788             :                 // look if we can find the corresponding table
     789           0 :                 bError = fillColumnRef( pColumnRef, xConnection, aSelEntry, _bListAction );
     790             : 
     791             :                 // we found a simple column so we must clear the function fields but only when the column name is '*'
     792             :                 // and the function is different to count
     793           0 :                 clearEntryFunctionField(_sFieldName,aSelEntry,_bListAction,nColumnId);
     794             :             }
     795             :             // do we have a aggregate function and only a function?
     796           0 :             else if ( SQL_ISRULE(pColumnRef,general_set_fct) )
     797             :             {
     798           0 :                 String sLocalizedFunctionName;
     799           0 :                 if ( GetFunctionName(pColumnRef->getChild(0)->getTokenID(),sLocalizedFunctionName) )
     800             :                 {
     801           0 :                     String sOldLocalizedFunctionName = aSelEntry->GetFunction();
     802           0 :                     aSelEntry->SetFunction(sLocalizedFunctionName);
     803           0 :                     sal_uInt32 nFunCount = pColumnRef->count() - 1;
     804           0 :                     sal_Int32 nFunctionType = FKT_AGGREGATE;
     805           0 :                     sal_Bool bQuote = sal_False;
     806             :                     // may be there exists only one parameter which is a column, fill all information into our fields
     807           0 :                     if ( nFunCount == 4 && SQL_ISRULE(pColumnRef->getChild(3),column_ref) )
     808           0 :                         bError = fillColumnRef( pColumnRef->getChild(3), xConnection, aSelEntry, _bListAction );
     809           0 :                     else if ( nFunCount == 3 ) // we have a COUNT(*) here, so take the first table
     810           0 :                         bError = fillColumnRef( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("*")), ::rtl::OUString(), xMetaData, aSelEntry, _bListAction );
     811             :                     else
     812             :                     {
     813           0 :                         nFunctionType |= FKT_NUMERIC;
     814           0 :                         bQuote = sal_True;
     815           0 :                         aSelEntry->SetDataType(DataType::DOUBLE);
     816           0 :                         aSelEntry->SetFieldType(TAB_NORMAL_FIELD);
     817             :                     }
     818             : 
     819             :                     // now parse the parameters
     820           0 :                     ::rtl::OUString sParameters;
     821           0 :                     for(sal_uInt32 function = 2; function < nFunCount; ++function) // we only want to parse the parameters of the function
     822           0 :                         pColumnRef->getChild(function)->parseNodeToStr( sParameters, xConnection, &rParser.getContext(), sal_True, bQuote );
     823             : 
     824           0 :                     aSelEntry->SetFunctionType(nFunctionType);
     825           0 :                     aSelEntry->SetField(sParameters);
     826           0 :                     if ( aSelEntry->IsGroupBy() )
     827             :                     {
     828           0 :                         sOldLocalizedFunctionName = m_aFunctionStrings.GetToken(comphelper::string::getTokenCount(m_aFunctionStrings, ';')-1);
     829           0 :                         aSelEntry->SetGroupBy(sal_False);
     830             :                     }
     831             : 
     832             :                     // append undo action
     833           0 :                     notifyFunctionFieldChanged(sOldLocalizedFunctionName,sLocalizedFunctionName,_bListAction, nColumnId);
     834             :                 }
     835             :                 else
     836           0 :                     OSL_FAIL("Unsupported function inserted!");
     837             : 
     838             :             }
     839             :             else
     840             :             {
     841             :                 // so we first clear the function field
     842           0 :                 clearEntryFunctionField(_sFieldName,aSelEntry,_bListAction,nColumnId);
     843           0 :                 ::rtl::OUString sFunction;
     844             :                 pColumnRef->parseNodeToStr( sFunction,
     845             :                                             xConnection,
     846           0 :                                             &rController.getParser().getContext(),
     847             :                                             sal_True,
     848           0 :                                             sal_True); // quote is to true because we need quoted elements inside the function
     849             : 
     850           0 :                 getDesignView()->fillFunctionInfo(pColumnRef,sFunction,aSelEntry);
     851             : 
     852           0 :                 if( SQL_ISRULEOR3(pColumnRef, position_exp, extract_exp, fold) ||
     853           0 :                     SQL_ISRULEOR3(pColumnRef, char_substring_fct, length_exp, char_value_fct) )
     854             :                     // a calculation has been found ( can be calc and function )
     855             :                 {
     856             :                     // now parse the whole statement
     857           0 :                     sal_uInt32 nFunCount = pColumnRef->count();
     858           0 :                     ::rtl::OUString sParameters;
     859           0 :                     for(sal_uInt32 function = 0; function < nFunCount; ++function)
     860           0 :                         pColumnRef->getChild(function)->parseNodeToStr( sParameters, xConnection, &rParser.getContext(), sal_True, sal_True );
     861             : 
     862           0 :                     sOldAlias = aSelEntry->GetAlias();
     863           0 :                     sal_Int32 nNewFunctionType = aSelEntry->GetFunctionType() | FKT_NUMERIC | FKT_OTHER;
     864           0 :                     aSelEntry->SetFunctionType(nNewFunctionType);
     865           0 :                     aSelEntry->SetField(sParameters);
     866             :                 }
     867             :                 else
     868             :                 {
     869           0 :                     aSelEntry->SetFieldAlias(sColumnAlias);
     870           0 :                     if ( SQL_ISRULE(pColumnRef,set_fct_spec) )
     871           0 :                         aSelEntry->SetFunctionType(/*FKT_NUMERIC | */FKT_OTHER);
     872             :                     else
     873           0 :                         aSelEntry->SetFunctionType(FKT_NUMERIC | FKT_OTHER);
     874             :                 }
     875             : 
     876           0 :                 aSelEntry->SetAlias(::rtl::OUString());
     877           0 :                 notifyTableFieldChanged(sOldAlias,aSelEntry->GetAlias(),_bListAction, nColumnId);
     878             :             }
     879             : 
     880           0 :             if ( i > 0 && !InsertField(aSelEntry,BROWSER_INVALIDID,sal_True,sal_False).is() ) // may we have to append more than one field
     881             :             { // the field could not be inserted
     882           0 :                 String sErrorMessage( ModuleRes( RID_STR_FIELD_DOESNT_EXIST ) );
     883           0 :                 sErrorMessage.SearchAndReplaceAscii("$name$",aSelEntry->GetField());
     884           0 :                 OSQLWarningBox( this, sErrorMessage ).Execute();
     885           0 :                 bError = sal_True;
     886             :             }
     887           0 :         }
     888             :     }
     889           0 :     delete pParseNode;
     890             : 
     891           0 :     return bError;
     892             : }
     893             : //------------------------------------------------------------------------------
     894           0 : sal_Bool OSelectionBrowseBox::SaveModified()
     895             : {
     896             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
     897           0 :     OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
     898           0 :     OTableFieldDescRef pEntry = NULL;
     899           0 :     sal_uInt16 nCurrentColumnPos = GetColumnPos(GetCurColumnId());
     900           0 :     if(getFields().size() > static_cast<sal_uInt16>(nCurrentColumnPos - 1))
     901           0 :         pEntry = getEntry(nCurrentColumnPos - 1);
     902             : 
     903           0 :     sal_Bool bWasEmpty = pEntry.is() ? pEntry->IsEmpty() : sal_False;
     904           0 :     sal_Bool bError         = sal_False;
     905           0 :     sal_Bool bListAction    = sal_False;
     906             : 
     907           0 :     if (pEntry.is() && Controller().Is() && Controller()->IsModified())
     908             :     {
     909             :         // fuer die Undo-Action
     910           0 :         String strOldCellContents,sNewValue;
     911           0 :         long nRow = GetRealRow(GetCurRow());
     912           0 :         sal_Bool bAppendRow = sal_False;
     913           0 :         switch (nRow)
     914             :         {
     915             :             case BROW_VIS_ROW:
     916             :                 {
     917           0 :                     sal_Bool bOldValue = m_pVisibleCell->GetBox().GetSavedValue() != STATE_NOCHECK;
     918           0 :                     strOldCellContents = bOldValue ? g_strOne : g_strZero;
     919           0 :                     sNewValue          = !bOldValue ? g_strOne : g_strZero;
     920             :                 }
     921           0 :                 if((m_bOrderByUnRelated || pEntry->GetOrderDir() == ORDER_NONE) &&
     922           0 :                    (m_bGroupByUnRelated || !pEntry->IsGroupBy()))
     923             :                 {
     924           0 :                     pEntry->SetVisible(m_pVisibleCell->GetBox().IsChecked());
     925             :                 }
     926             :                 else
     927             :                 {
     928           0 :                     pEntry->SetVisible(sal_True);
     929           0 :                     m_pVisibleCell->GetBox().Check();
     930             :                 }
     931           0 :                 break;
     932             : 
     933             :             case BROW_FIELD_ROW:
     934             :             {
     935           0 :                 String aFieldName(m_pFieldCell->GetText());
     936             :                 try
     937             :                 {
     938           0 :                     if (!aFieldName.Len())
     939             :                     {
     940           0 :                         OTableFieldDescRef pNewEntry = new OTableFieldDesc();
     941           0 :                         pNewEntry->SetColumnId( pEntry->GetColumnId() );
     942           0 :                         ::std::replace(getFields().begin(),getFields().end(),pEntry,pNewEntry);
     943           0 :                         sal_uInt16 nCol = GetCurColumnId();
     944           0 :                         for (int i = 0; i < m_nVisibleCount; i++)   // Spalte neu zeichnen
     945           0 :                             RowModified(i,nCol);
     946             :                     }
     947             :                     else
     948             :                     {
     949           0 :                         strOldCellContents = pEntry->GetField();
     950           0 :                         bListAction = sal_True;
     951           0 :                         if ( !m_bInUndoMode )
     952           0 :                             rController.GetUndoManager().EnterListAction(String(),String());
     953             : 
     954           0 :                         sal_uInt16 nPos = m_pFieldCell->GetEntryPos(aFieldName);
     955           0 :                         String aAliasName = pEntry->GetAlias();
     956           0 :                         if ( nPos != COMBOBOX_ENTRY_NOTFOUND && !aAliasName.Len() && comphelper::string::getTokenCount(aFieldName, '.') > 1 )
     957             :                         { // special case, we have a table field so we must cut the table name
     958           0 :                             String sTableAlias = aFieldName.GetToken(0,'.');
     959           0 :                             pEntry->SetAlias(sTableAlias);
     960           0 :                             String sColumnName = aFieldName.Copy(sTableAlias.Len()+1,aFieldName.Len() - sTableAlias.Len() -1);
     961           0 :                             Reference<XConnection> xConnection = rController.getConnection();
     962           0 :                             if ( !xConnection.is() )
     963           0 :                                 return sal_False;
     964           0 :                             bError = fillColumnRef( sColumnName, sTableAlias, xConnection->getMetaData(), pEntry, bListAction );
     965             :                         }
     966             :                         else
     967           0 :                             bError = sal_True;
     968             : 
     969           0 :                         if ( bError )
     970           0 :                             bError = saveField(aFieldName,pEntry,bListAction);
     971             :                     }
     972             :                 }
     973           0 :                 catch(Exception&)
     974             :                 {
     975           0 :                     bError = sal_True;
     976             :                 }
     977           0 :                 if ( bError )
     978             :                 {
     979           0 :                     sNewValue = aFieldName;
     980           0 :                     if ( !m_bInUndoMode )
     981           0 :                         static_cast<OQueryController&>(getDesignView()->getController()).GetUndoManager().LeaveListAction();
     982           0 :                     bListAction = sal_False;
     983             :                 }
     984             :                 else
     985           0 :                     sNewValue = pEntry->GetField();
     986           0 :                 rController.InvalidateFeature( ID_BROWSER_QUERY_EXECUTE );
     987             :             }
     988           0 :             break;
     989             : 
     990             :             case BROW_TABLE_ROW:
     991             :             {
     992           0 :                 String aAliasName = m_pTableCell->GetSelectEntry();
     993           0 :                 strOldCellContents = pEntry->GetAlias();
     994           0 :                 if ( m_pTableCell->GetSelectEntryPos() != 0 )
     995             :                 {
     996           0 :                     pEntry->SetAlias(aAliasName);
     997             :                     // we have to set the table name as well as the table window
     998           0 :                     OJoinTableView::OTableWindowMap* pTabWinList = getDesignView()->getTableView()->GetTabWinMap();
     999           0 :                     if (pTabWinList)
    1000             :                     {
    1001           0 :                         OJoinTableView::OTableWindowMapIterator aIter = pTabWinList->find(aAliasName);
    1002           0 :                         if(aIter != pTabWinList->end())
    1003             :                         {
    1004           0 :                             OQueryTableWindow* pEntryTab = static_cast<OQueryTableWindow*>(aIter->second);
    1005           0 :                             if (pEntryTab)
    1006             :                             {
    1007           0 :                                 pEntry->SetTable(pEntryTab->GetTableName());
    1008           0 :                                 pEntry->SetTabWindow(pEntryTab);
    1009             :                             }
    1010             :                         }
    1011             :                     }
    1012             :                 }
    1013             :                 else
    1014             :                 {
    1015           0 :                     pEntry->SetAlias(::rtl::OUString());
    1016           0 :                     pEntry->SetTable(::rtl::OUString());
    1017           0 :                     pEntry->SetTabWindow(NULL);
    1018             :                 }
    1019           0 :                 sNewValue = pEntry->GetAlias();
    1020             : 
    1021           0 :             }   break;
    1022             : 
    1023             :             case BROW_ORDER_ROW:
    1024             :             {
    1025           0 :                 strOldCellContents = String::CreateFromInt32((sal_uInt16)pEntry->GetOrderDir());
    1026           0 :                 sal_uInt16 nIdx = m_pOrderCell->GetSelectEntryPos();
    1027           0 :                 if (nIdx == sal_uInt16(-1))
    1028           0 :                     nIdx = 0;
    1029           0 :                 pEntry->SetOrderDir(EOrderDir(nIdx));
    1030           0 :                 if(!m_bOrderByUnRelated)
    1031             :                 {
    1032           0 :                     pEntry->SetVisible(sal_True);
    1033           0 :                     m_pVisibleCell->GetBox().Check();
    1034           0 :                     RowModified(GetBrowseRow(BROW_VIS_ROW), GetCurColumnId());
    1035             :                 }
    1036           0 :                 sNewValue = String::CreateFromInt32((sal_uInt16)pEntry->GetOrderDir());
    1037           0 :             }   break;
    1038             : 
    1039             :             case BROW_COLUMNALIAS_ROW:
    1040           0 :                 strOldCellContents = pEntry->GetFieldAlias();
    1041           0 :                 pEntry->SetFieldAlias(m_pTextCell->GetText());
    1042           0 :                 sNewValue = pEntry->GetFieldAlias();
    1043           0 :                 break;
    1044             :             case BROW_FUNCTION_ROW:
    1045             :                 {
    1046           0 :                     strOldCellContents = pEntry->GetFunction();
    1047           0 :                     sal_uInt16 nPos = m_pFunctionCell->GetSelectEntryPos();
    1048             :                     // Diese Funktionen stehen nur unter CORE zur Verf�gung
    1049           0 :                     String sFunctionName        = m_pFunctionCell->GetEntry(nPos);
    1050           0 :                     String sGroupFunctionName   = m_aFunctionStrings.GetToken(comphelper::string::getTokenCount(m_aFunctionStrings, ';')-1);
    1051           0 :                     sal_Bool bGroupBy = sal_False;
    1052           0 :                     if ( sGroupFunctionName.Equals(sFunctionName) ) // check if the function name is GROUP
    1053             :                     {
    1054           0 :                         bGroupBy = sal_True;
    1055             : 
    1056           0 :                         if ( !m_bGroupByUnRelated && !pEntry->IsVisible() )
    1057             :                         {
    1058             :                             // we have to change the visblie flag, so we must append also an undo action
    1059           0 :                             pEntry->SetVisible(sal_True);
    1060           0 :                             m_pVisibleCell->GetBox().Check();
    1061           0 :                             appendUndoAction(g_strZero,g_strOne,BROW_VIS_ROW,bListAction);
    1062           0 :                             RowModified(GetBrowseRow(BROW_VIS_ROW), GetCurColumnId());
    1063             :                         }
    1064             : 
    1065           0 :                         pEntry->SetFunction(String());
    1066           0 :                         pEntry->SetFunctionType(pEntry->GetFunctionType() & ~FKT_AGGREGATE );
    1067             :                     }
    1068           0 :                     else if ( nPos ) // we found an aggregate function
    1069             :                     {
    1070           0 :                         pEntry->SetFunctionType(pEntry->GetFunctionType() | FKT_AGGREGATE );
    1071           0 :                         pEntry->SetFunction(sFunctionName);
    1072             :                     }
    1073             :                     else
    1074             :                     {
    1075           0 :                         sFunctionName = String();
    1076           0 :                         pEntry->SetFunction(String());
    1077           0 :                         pEntry->SetFunctionType(pEntry->GetFunctionType() & ~FKT_AGGREGATE );
    1078             :                     }
    1079             : 
    1080           0 :                     pEntry->SetGroupBy(bGroupBy);
    1081             : 
    1082           0 :                     sNewValue = sFunctionName;
    1083             :                 }
    1084           0 :                 break;
    1085             :             default:
    1086             :             {
    1087           0 :                 Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
    1088           0 :                 if(!xConnection.is())
    1089             :                     break;
    1090             : 
    1091           0 :                 sal_uInt16  nIdx = sal_uInt16(nRow - BROW_CRIT1_ROW);
    1092           0 :                 String aText = comphelper::string::stripStart(m_pTextCell->GetText(), ' ');
    1093             : 
    1094           0 :                 ::rtl::OUString aCrit;
    1095           0 :                 if(aText.Len())
    1096             :                 {
    1097           0 :                     ::rtl::OUString aErrorMsg;
    1098           0 :                     Reference<XPropertySet> xColumn;
    1099           0 :                     OSQLParseNode* pParseNode = getDesignView()->getPredicateTreeFromEntry(pEntry,aText,aErrorMsg,xColumn);
    1100             : 
    1101           0 :                     if (pParseNode)
    1102             :                     {
    1103             :                         pParseNode->parseNodeToPredicateStr(aCrit,
    1104             :                                                             xConnection,
    1105           0 :                                                             static_cast<OQueryController&>(getDesignView()->getController()).getNumberFormatter(),
    1106             :                                                             xColumn,
    1107             :                                                             getDesignView()->getLocale(),
    1108           0 :                                                             static_cast<sal_Char>(getDesignView()->getDecimalSeparator().toChar()),
    1109           0 :                                                             &(static_cast<OQueryController&>(getDesignView()->getController()).getParser().getContext()));
    1110           0 :                         delete pParseNode;
    1111             :                     }
    1112             :                     else
    1113             :                     {
    1114           0 :                         if(xColumn.is())
    1115             :                         {
    1116           0 :                             sal_Int32 nType = 0;
    1117           0 :                             xColumn->getPropertyValue(PROPERTY_TYPE) >>= nType;
    1118           0 :                             switch(nType)
    1119             :                             {
    1120             :                                 case DataType::CHAR:
    1121             :                                 case DataType::VARCHAR:
    1122             :                                 case DataType::LONGVARCHAR:
    1123             :                                 case DataType::CLOB:
    1124           0 :                                     if(aText.GetChar(0) != '\'' || aText.GetChar(aText.Len() -1) != '\'')
    1125             :                                     {
    1126           0 :                                         aText.SearchAndReplaceAll(rtl::OUString("'"), rtl::OUString("''"));
    1127           0 :                                         String aTmp(rtl::OUString("'"));
    1128           0 :                                         (aTmp += aText) += rtl::OUString("'");
    1129           0 :                                         aText = aTmp;
    1130             :                                     }
    1131           0 :                                     break;
    1132             :                                 default:
    1133             :                                     ;
    1134             :                             }
    1135           0 :                             ::connectivity::OSQLParser& rParser = static_cast<OQueryController&>(getDesignView()->getController()).getParser();
    1136             :                             pParseNode = rParser.predicateTree(aErrorMsg,
    1137             :                                                                 aText,
    1138           0 :                                                                 static_cast<OQueryController&>(getDesignView()->getController()).getNumberFormatter(),
    1139           0 :                                                                 xColumn);
    1140           0 :                             if (pParseNode)
    1141             :                             {
    1142             :                                 pParseNode->parseNodeToPredicateStr(aCrit,
    1143             :                                                                     xConnection,
    1144           0 :                                                                     static_cast<OQueryController&>(getDesignView()->getController()).getNumberFormatter(),
    1145             :                                                                     xColumn,
    1146             :                                                                     getDesignView()->getLocale(),
    1147           0 :                                                                     static_cast<sal_Char>(getDesignView()->getDecimalSeparator().toChar()),
    1148           0 :                                                                     &(static_cast<OQueryController&>(getDesignView()->getController()).getParser().getContext()));
    1149           0 :                                 delete pParseNode;
    1150             :                             }
    1151             :                             else
    1152             :                             {
    1153           0 :                                 if ( !m_bDisableErrorBox )
    1154             :                                 {
    1155           0 :                                     OSQLWarningBox( this, aErrorMsg ).Execute();
    1156             :                                 }
    1157           0 :                                 bError = sal_True;
    1158             :                             }
    1159             :                         }
    1160             :                         else
    1161             :                         {
    1162           0 :                             if ( !m_bDisableErrorBox )
    1163             :                             {
    1164           0 :                                 OSQLWarningBox( this, aErrorMsg ).Execute();
    1165             :                             }
    1166           0 :                             bError = sal_True;
    1167             :                         }
    1168           0 :                     }
    1169             :                 }
    1170           0 :                 strOldCellContents = pEntry->GetCriteria(nIdx);
    1171           0 :                 pEntry->SetCriteria(nIdx, aCrit);
    1172           0 :                 sNewValue = pEntry->GetCriteria(nIdx);
    1173           0 :                 if(!aCrit.isEmpty() && nRow >= (GetRowCount()-1))
    1174           0 :                     bAppendRow = sal_True;
    1175             :             }
    1176             :         }
    1177           0 :         if(!bError && Controller())
    1178           0 :             Controller()->ClearModified();
    1179             : 
    1180           0 :         RowModified(GetCurRow(), GetCurColumnId());
    1181             : 
    1182           0 :         if ( bAppendRow )
    1183             :         {
    1184           0 :             RowInserted( GetRowCount()-1, 1, sal_True );
    1185           0 :             m_bVisibleRow.push_back(sal_True);
    1186           0 :             ++m_nVisibleCount;
    1187             :         }
    1188             : 
    1189           0 :         if(!bError)
    1190             :         {
    1191             :             // und noch die Undo-Action fuer das Ganze
    1192           0 :             appendUndoAction(strOldCellContents,sNewValue,nRow);
    1193             : 
    1194           0 :         }
    1195             :     }
    1196             : 
    1197             :     // habe ich Daten in einer FieldDescription gespeichert, die vorher leer war und es nach den Aenderungen nicht mehr ist ?
    1198           0 :     if ( pEntry.is() && bWasEmpty && !pEntry->IsEmpty() && !bError )
    1199             :     {
    1200             :         // Default auf sichtbar
    1201           0 :         pEntry->SetVisible(sal_True);
    1202           0 :         appendUndoAction(g_strZero,g_strOne,BROW_VIS_ROW,bListAction);
    1203           0 :         RowModified(BROW_VIS_ROW, GetCurColumnId());
    1204             : 
    1205             :         // wenn noetig neue freie Spalten anlegen
    1206             :         sal_uInt16 nDummy;
    1207           0 :         CheckFreeColumns(nDummy);
    1208             :     }
    1209             : 
    1210           0 :     if ( bListAction && !m_bInUndoMode )
    1211           0 :         static_cast<OQueryController&>(getDesignView()->getController()).GetUndoManager().LeaveListAction();
    1212             : 
    1213           0 :     return pEntry != NULL && !bError;
    1214             : }
    1215             : 
    1216             : //------------------------------------------------------------------------------
    1217           0 : sal_Bool OSelectionBrowseBox::SeekRow(long nRow)
    1218             : {
    1219             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1220           0 :     sal_Bool bRet = sal_False;
    1221             : 
    1222           0 :     m_nSeekRow = nRow;
    1223           0 :     if (nRow < m_nVisibleCount )
    1224           0 :         bRet = sal_True;
    1225             : 
    1226           0 :     return bRet;
    1227             : }
    1228             : 
    1229             : //------------------------------------------------------------------------------
    1230           0 : void OSelectionBrowseBox::PaintCell(OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColumnId) const
    1231             : {
    1232             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1233           0 :     rDev.SetClipRegion( rRect );
    1234             : 
    1235           0 :     OTableFieldDescRef pEntry = NULL;
    1236           0 :     sal_uInt16 nPos = GetColumnPos(nColumnId);
    1237           0 :     if(getFields().size() > sal_uInt16(nPos - 1))
    1238           0 :         pEntry = getFields()[nPos - 1];
    1239             : 
    1240           0 :     if (!pEntry.is())
    1241           0 :         return;
    1242             : 
    1243           0 :     long nRow = GetRealRow(m_nSeekRow);
    1244           0 :     if (nRow == BROW_VIS_ROW)
    1245           0 :         PaintTristate(rDev, rRect, pEntry->IsVisible() ? STATE_CHECK : STATE_NOCHECK);
    1246             :     else
    1247           0 :         rDev.DrawText(rRect, GetCellText(nRow, nColumnId),TEXT_DRAW_VCENTER);
    1248             : 
    1249           0 :     rDev.SetClipRegion( );
    1250             : }
    1251             : 
    1252             : //------------------------------------------------------------------------------
    1253           0 : void OSelectionBrowseBox::PaintStatusCell(OutputDevice& rDev, const Rectangle& rRect) const
    1254             : {
    1255             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1256           0 :     Rectangle aRect(rRect);
    1257           0 :     aRect.TopLeft().Y() -= 2;
    1258           0 :     String  aLabel(ModuleRes(STR_QUERY_HANDLETEXT));
    1259             : 
    1260             :     // ab BROW_CRIT2_ROW werden alle Zeilen mit "oder" angegeben
    1261           0 :     xub_StrLen nToken = (xub_StrLen) (m_nSeekRow >= GetBrowseRow(BROW_CRIT2_ROW))
    1262             :                                 ?
    1263           0 :             xub_StrLen(BROW_CRIT2_ROW) : xub_StrLen(GetRealRow(m_nSeekRow));
    1264           0 :     rDev.DrawText(aRect, aLabel.GetToken(nToken),TEXT_DRAW_VCENTER);
    1265           0 : }
    1266             : 
    1267             : //------------------------------------------------------------------------------
    1268           0 : void OSelectionBrowseBox::RemoveColumn(sal_uInt16 _nColumnId)
    1269             : {
    1270             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1271           0 :     OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
    1272             : 
    1273           0 :     sal_uInt16 nPos = GetColumnPos(_nColumnId);
    1274             :         // das Control sollte immer genau eine Spalte mehr haben, naemlich die HandleColumn
    1275             :     OSL_ENSURE((nPos == 0) || (nPos <= getFields().size()), "OSelectionBrowseBox::RemoveColumn : invalid parameter nColId");
    1276             :         // ColId ist bei mir gleichbedeutend mit Position, und da sollte die Bedingung natuerlich zutreffen
    1277             : 
    1278           0 :     sal_uInt16 nCurCol = GetCurColumnId();
    1279           0 :     long nCurrentRow = GetCurRow();
    1280             : 
    1281           0 :     DeactivateCell();
    1282             : 
    1283           0 :     getFields().erase( getFields().begin() + (nPos - 1) );
    1284           0 :     OTableFieldDescRef pEntry = new OTableFieldDesc();
    1285           0 :     pEntry->SetColumnId(_nColumnId);
    1286           0 :     getFields().push_back(pEntry);
    1287             : 
    1288           0 :     EditBrowseBox::RemoveColumn( _nColumnId );
    1289           0 :     InsertDataColumn( _nColumnId , String(), DEFAULT_SIZE, HIB_STDSTYLE, HEADERBAR_APPEND);
    1290             : 
    1291             :     // Neuzeichnen
    1292           0 :     Rectangle aInvalidRect = GetInvalidRect( _nColumnId );
    1293           0 :     Invalidate( aInvalidRect );
    1294             : 
    1295           0 :     ActivateCell( nCurrentRow, nCurCol );
    1296             : 
    1297           0 :     rController.setModified( sal_True );
    1298             : 
    1299           0 :     invalidateUndoRedo();
    1300           0 : }
    1301             : 
    1302             : //------------------------------------------------------------------------------
    1303           0 : void OSelectionBrowseBox::RemoveField(sal_uInt16 nColumnId )
    1304             : {
    1305             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1306           0 :     OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
    1307             : 
    1308           0 :     sal_uInt16 nPos = GetColumnPos(nColumnId);
    1309             :     OSL_ENSURE(getFields().size() > sal_uInt16(nPos-1),"ID is to great!");
    1310             : 
    1311           0 :     OTableFieldDescRef pDesc = getEntry((sal_uInt32)(nPos - 1)) ;
    1312           0 :     pDesc->SetColWidth( (sal_uInt16)GetColumnWidth(nColumnId) );    // hat er sich vorher leider nicht gemerkt
    1313             : 
    1314             :     // UndoAction erzeugen
    1315           0 :     if ( !m_bInUndoMode )
    1316             :     {
    1317           0 :         OTabFieldDelUndoAct* pUndoAction = new OTabFieldDelUndoAct( this );
    1318           0 :         pUndoAction->SetTabFieldDescr(pDesc);
    1319           0 :         pUndoAction->SetColumnPosition(nPos);
    1320           0 :         rController.addUndoActionAndInvalidate( pUndoAction );
    1321             :     }
    1322             : 
    1323           0 :     RemoveColumn(nColumnId);
    1324             : 
    1325           0 :     invalidateUndoRedo();
    1326           0 : }
    1327             : 
    1328             : //------------------------------------------------------------------------------
    1329           0 : void OSelectionBrowseBox::adjustSelectionMode( sal_Bool _bClickedOntoHeader, sal_Bool _bClickedOntoHandleCol )
    1330             : {
    1331             :     // wenn ein Header selectiert wird, mu� die selection angezeigt werden, sonst nicht)
    1332           0 :     if ( _bClickedOntoHeader )
    1333             :     {
    1334           0 :         if (0 == GetSelectColumnCount() )
    1335             :             // wenn es schon eine selektierte Spalte gibt, bin ich schon im richtigen Modus
    1336           0 :             if ( BROWSER_HIDESELECT == ( m_nMode & BROWSER_HIDESELECT ) )
    1337             :             {
    1338           0 :                 m_nMode &= ~BROWSER_HIDESELECT;
    1339           0 :                 m_nMode |= BROWSER_MULTISELECTION;
    1340           0 :                 SetMode( m_nMode );
    1341             :             }
    1342             :     }
    1343           0 :     else if ( BROWSER_HIDESELECT != ( m_nMode & BROWSER_HIDESELECT ) )
    1344             :     {
    1345           0 :         if ( GetSelectColumnCount() != 0 )
    1346           0 :             SetNoSelection();
    1347             : 
    1348           0 :         if ( _bClickedOntoHandleCol )
    1349             :         {
    1350           0 :             m_nMode |= BROWSER_HIDESELECT;
    1351           0 :             m_nMode &= ~BROWSER_MULTISELECTION;
    1352           0 :             SetMode( m_nMode );
    1353             :         }
    1354             :     }
    1355           0 : }
    1356             : 
    1357             : //------------------------------------------------------------------------------
    1358           0 : void OSelectionBrowseBox::MouseButtonDown(const BrowserMouseEvent& rEvt)
    1359             : {
    1360             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1361           0 :     if( rEvt.IsLeft() )
    1362             :     {
    1363           0 :         sal_Bool bOnHandle = HANDLE_ID == rEvt.GetColumnId();
    1364           0 :         sal_Bool bOnHeader = ( rEvt.GetRow() < 0 ) && !bOnHandle;
    1365           0 :         adjustSelectionMode( bOnHeader, bOnHandle );
    1366             :     }
    1367           0 :     EditBrowseBox::MouseButtonDown(rEvt);
    1368           0 : }
    1369             : 
    1370             : //------------------------------------------------------------------------------
    1371           0 : void OSelectionBrowseBox::MouseButtonUp(const BrowserMouseEvent& rEvt)
    1372             : {
    1373             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1374           0 :     EditBrowseBox::MouseButtonUp( rEvt );
    1375           0 :     static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( ID_BROWSER_QUERY_EXECUTE );
    1376           0 : }
    1377             : 
    1378             : //------------------------------------------------------------------------------
    1379           0 : void OSelectionBrowseBox::KeyInput( const KeyEvent& rEvt )
    1380             : {
    1381             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1382           0 :     if (IsColumnSelected(GetCurColumnId()))
    1383             :     {
    1384           0 :         if (rEvt.GetKeyCode().GetCode() == KEY_DELETE &&    // Delete rows
    1385           0 :             !rEvt.GetKeyCode().IsShift() &&
    1386           0 :             !rEvt.GetKeyCode().IsMod1())
    1387             :         {
    1388           0 :             RemoveField(GetCurColumnId());
    1389           0 :             return;
    1390             :         }
    1391             :     }
    1392           0 :     EditBrowseBox::KeyInput(rEvt);
    1393             : }
    1394             : 
    1395             : 
    1396             : //------------------------------------------------------------------------------
    1397           0 : sal_Int8 OSelectionBrowseBox::AcceptDrop( const BrowserAcceptDropEvent& rEvt )
    1398             : {
    1399             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1400           0 :     sal_Int8 nDropAction = DND_ACTION_NONE;
    1401           0 :     if  ( rEvt.GetRow() >= -1 )
    1402             :     {
    1403           0 :         if ( IsEditing() )
    1404             :         {
    1405             :             // allow the asterix again
    1406           0 :             m_bDisableErrorBox = sal_True;
    1407           0 :             SaveModified();
    1408           0 :             m_bDisableErrorBox = sal_False;
    1409           0 :             DeactivateCell();
    1410             :         }
    1411             :         // check if the format is already supported, if not deactivate the current cell and try again
    1412           0 :         if ( OJoinExchObj::isFormatAvailable(GetDataFlavors()) )
    1413           0 :             nDropAction = DND_ACTION_LINK;
    1414             :     }
    1415             : 
    1416           0 :     return nDropAction;
    1417             : }
    1418             : 
    1419             : //------------------------------------------------------------------------------
    1420           0 : sal_Int8 OSelectionBrowseBox::ExecuteDrop( const BrowserExecuteDropEvent& _rEvt )
    1421             : {
    1422             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1423             : 
    1424           0 :     TransferableDataHelper aDropped(_rEvt.maDropEvent.Transferable);
    1425           0 :     if (!OJoinExchObj::isFormatAvailable(aDropped.GetDataFlavorExVector()))
    1426             :     {
    1427             :         OSL_FAIL("OSelectionBrowseBox::ExecuteDrop: this should never have passed AcceptDrop!");
    1428           0 :         return DND_ACTION_NONE;
    1429             :     }
    1430             : 
    1431           0 :     OTableFieldDesc aInfo;
    1432             :     // Einfuegen des Feldes an der gewuenschten Position
    1433           0 :     OJoinExchangeData jxdSource = OJoinExchObj::GetSourceDescription(_rEvt.maDropEvent.Transferable);
    1434           0 :     InsertField(jxdSource);
    1435             : 
    1436           0 :     return DND_ACTION_LINK;
    1437             : }
    1438             : 
    1439             : //------------------------------------------------------------------------------
    1440           0 : OTableFieldDescRef OSelectionBrowseBox::AppendNewCol( sal_uInt16 nCnt)
    1441             : {
    1442             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1443             :     // es koennen mehrere angelegt werden, aber der Erste
    1444             :     // wird returnt
    1445           0 :     sal_uInt32 nCount = getFields().size();
    1446           0 :     for (sal_uInt16 i=0 ; i<nCnt ; i++)
    1447             :     {
    1448           0 :         OTableFieldDescRef pEmptyEntry = new OTableFieldDesc();
    1449           0 :         getFields().push_back(pEmptyEntry);
    1450           0 :         sal_uInt16 nColumnId = sal::static_int_cast< sal_uInt16 >(getFields().size());
    1451           0 :         pEmptyEntry->SetColumnId( nColumnId );
    1452             : 
    1453           0 :         InsertDataColumn( nColumnId , String(), DEFAULT_SIZE, HIB_STDSTYLE, HEADERBAR_APPEND);
    1454           0 :     }
    1455             : 
    1456           0 :     return getFields()[nCount];
    1457             : }
    1458             : 
    1459             : //------------------------------------------------------------------------------
    1460           0 : void OSelectionBrowseBox::DeleteFields(const String& rAliasName)
    1461             : {
    1462             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1463           0 :     if (!getFields().empty())
    1464             :     {
    1465           0 :         sal_uInt16 nColId = GetCurColumnId();
    1466           0 :         sal_uInt32 nRow = GetCurRow();
    1467             : 
    1468           0 :         sal_Bool bWasEditing = IsEditing();
    1469           0 :         if (bWasEditing)
    1470           0 :             DeactivateCell();
    1471             : 
    1472           0 :         OTableFields::reverse_iterator aIter = getFields().rbegin();
    1473           0 :         OTableFieldDescRef pEntry = NULL;
    1474           0 :         for(sal_uInt16 nPos=sal::static_int_cast< sal_uInt16 >(getFields().size());aIter != getFields().rend();++aIter,--nPos)
    1475             :         {
    1476           0 :             pEntry = *aIter;
    1477           0 :             if ( pEntry->GetAlias().equals( rAliasName ) )
    1478             :             {
    1479           0 :                 RemoveField( GetColumnId( nPos ) );
    1480           0 :                 break;
    1481             :             }
    1482             :         }
    1483             : 
    1484           0 :         if (bWasEditing)
    1485           0 :             ActivateCell(nRow , nColId);
    1486             :     }
    1487           0 : }
    1488             : 
    1489             : //------------------------------------------------------------------------------
    1490           0 : void OSelectionBrowseBox::SetColWidth(sal_uInt16 nColId, long nNewWidth)
    1491             : {
    1492             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1493           0 :     sal_Bool bWasEditing = IsEditing();
    1494           0 :     if (bWasEditing)
    1495           0 :         DeactivateCell();
    1496             : 
    1497             :     // die Basisklasse machen lassen
    1498           0 :     SetColumnWidth(nColId, nNewWidth);
    1499             : 
    1500             :     // der FieldDescription Bescheid sagen
    1501           0 :     OTableFieldDescRef pEntry = getEntry(GetColumnPos(nColId) - 1);
    1502           0 :     if (pEntry.is())
    1503           0 :         pEntry->SetColWidth(sal_uInt16(GetColumnWidth(nColId)));
    1504             : 
    1505           0 :     if (bWasEditing)
    1506           0 :         ActivateCell(GetCurRow(), GetCurColumnId());
    1507           0 : }
    1508             : 
    1509             : //------------------------------------------------------------------------------
    1510           0 : Rectangle OSelectionBrowseBox::GetInvalidRect( sal_uInt16 nColId )
    1511             : {
    1512             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1513             :     //////////////////////////////////////////////////////////////////////
    1514             :     // Rechteck ist erst einmal der gesamte Outputbereich des Fensters
    1515           0 :     Rectangle aInvalidRect( Point(0,0), GetOutputSizePixel() );
    1516             : 
    1517             :     //////////////////////////////////////////////////////////////////////
    1518             :     // Dann wird die linke Seite angepasst
    1519           0 :     Rectangle aFieldRect(GetCellRect( 0, nColId )); // used instead of GetFieldRectPixel
    1520           0 :     aInvalidRect.Left() = aFieldRect.Left();
    1521             : 
    1522           0 :     return aInvalidRect;
    1523             : }
    1524             : 
    1525             : //------------------------------------------------------------------------------
    1526           0 : void OSelectionBrowseBox::InsertColumn(OTableFieldDescRef pEntry, sal_uInt16& _nColumnPosition)
    1527             : {
    1528             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1529             :         // das Control sollte immer genau eine Spalte mehr haben, naemlich die HandleColumn
    1530             :     OSL_ENSURE(_nColumnPosition == BROWSER_INVALIDID || (_nColumnPosition <= (long)getFields().size()), "OSelectionBrowseBox::InsertColumn : invalid parameter nColId.");
    1531             :         // -1 heisst ganz hinten, Count heisst ganz hinten, der Rest bezeichnet eine richtige Position
    1532             : 
    1533           0 :     sal_uInt16 nCurCol = GetCurColumnId();
    1534           0 :     long nCurrentRow = GetCurRow();
    1535             : 
    1536           0 :     DeactivateCell();
    1537             : 
    1538             :     // remember the column id of the current positon
    1539           0 :     sal_uInt16 nColumnId = GetColumnId(_nColumnPosition);
    1540             :     // Wenn zu klein oder zu gross, auf Ende der Liste setzen
    1541           0 :     if ((_nColumnPosition == BROWSER_INVALIDID) || (_nColumnPosition >= getFields().size()))   // Anhaengen des Feldes
    1542             :     {
    1543           0 :         if (FindFirstFreeCol(_nColumnPosition) == NULL)  // keine freie Column mehr
    1544             :         {
    1545           0 :             AppendNewCol(1);
    1546             :             _nColumnPosition = sal::static_int_cast< sal_uInt16 >(
    1547           0 :                 getFields().size());
    1548             :         }
    1549             :         else
    1550           0 :             ++_nColumnPosition; // innerhalb der vorgegebenen Liste
    1551           0 :         nColumnId = GetColumnId(_nColumnPosition);
    1552           0 :         pEntry->SetColumnId( nColumnId );
    1553           0 :         getFields()[ _nColumnPosition - 1] = pEntry;
    1554             :     }
    1555             : 
    1556             :     // check if the column ids are identical, if not we have to move
    1557           0 :     if ( pEntry->GetColumnId() != nColumnId )
    1558             :     {
    1559           0 :         sal_uInt16 nOldPosition = GetColumnPos(pEntry->GetColumnId());
    1560             :         OSL_ENSURE( nOldPosition != 0,"Old position was 0. Not possible!");
    1561           0 :         SetColumnPos(pEntry->GetColumnId(),_nColumnPosition);
    1562             :         // we have to delete an empty field for the fields list, because the columns must have equal length
    1563           0 :         if ( nOldPosition > 0 && nOldPosition <= getFields().size() )
    1564           0 :             getFields()[nOldPosition - 1] = pEntry;
    1565             : 
    1566           0 :         ColumnMoved(pEntry->GetColumnId(),sal_False);
    1567             :     }
    1568             : 
    1569           0 :     if ( pEntry->GetFunctionType() & (FKT_AGGREGATE) )
    1570             :     {
    1571           0 :         String sFunctionName = pEntry->GetFunction();
    1572           0 :         if ( GetFunctionName(sal_uInt32(-1),sFunctionName) )
    1573           0 :             pEntry->SetFunction(sFunctionName);
    1574             :     }
    1575             : 
    1576           0 :     nColumnId = pEntry->GetColumnId();
    1577             : 
    1578           0 :     SetColWidth(nColumnId,getDesignView()->getColWidth(GetColumnPos(nColumnId)-1));
    1579             :     // Neuzeichnen
    1580           0 :     Rectangle aInvalidRect = GetInvalidRect( nColumnId );
    1581           0 :     Invalidate( aInvalidRect );
    1582             : 
    1583           0 :     ActivateCell( nCurrentRow, nCurCol );
    1584           0 :     static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
    1585             : 
    1586           0 :     invalidateUndoRedo();
    1587           0 : }
    1588             : 
    1589             : //------------------------------------------------------------------------------
    1590           0 : OTableFieldDescRef OSelectionBrowseBox::InsertField(const OJoinExchangeData& jxdSource, sal_uInt16 _nColumnPosition, sal_Bool bVis, sal_Bool bActivate)
    1591             : {
    1592             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1593           0 :     OQueryTableWindow* pSourceWin = static_cast<OQueryTableWindow*>(jxdSource.pListBox->GetTabWin());
    1594           0 :     if (!pSourceWin)
    1595           0 :         return NULL;
    1596             : 
    1597             :     // Namen/Position des selektierten Feldes
    1598           0 :     String aFieldName = jxdSource.pListBox->GetEntryText(jxdSource.pEntry);
    1599           0 :     sal_uInt32 nFieldIndex = jxdSource.pListBox->GetModel()->GetAbsPos(jxdSource.pEntry);
    1600           0 :     OTableFieldInfo* pInf = static_cast<OTableFieldInfo*>(jxdSource.pEntry->GetUserData());
    1601             : 
    1602             :     // eine DragInfo aufbauen, damit ich mich auf das andere InsertField zurueckziehen kann
    1603           0 :     OTableFieldDescRef aInfo = new OTableFieldDesc(pSourceWin->GetTableName(),aFieldName);
    1604           0 :     aInfo->SetTabWindow(pSourceWin);
    1605           0 :     aInfo->SetFieldIndex(nFieldIndex);
    1606           0 :     aInfo->SetFieldType(pInf->GetKeyType());
    1607           0 :     aInfo->SetAlias(pSourceWin->GetAliasName());
    1608             : 
    1609           0 :     aInfo->SetDataType(pInf->GetDataType());
    1610           0 :     aInfo->SetVisible(bVis);
    1611             : 
    1612           0 :     return InsertField(aInfo, _nColumnPosition, bVis, bActivate);
    1613             : }
    1614             : 
    1615             : //------------------------------------------------------------------------------
    1616           0 : OTableFieldDescRef OSelectionBrowseBox::InsertField(const OTableFieldDescRef& _rInfo, sal_uInt16 _nColumnPosition, sal_Bool bVis, sal_Bool bActivate)
    1617             : {
    1618             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1619             : 
    1620           0 :     if(m_nMaxColumns && m_nMaxColumns <= FieldsCount())
    1621           0 :         return NULL;
    1622           0 :     if (bActivate)
    1623           0 :         SaveModified();
    1624             : 
    1625             :     // Neue Spaltenbeschreibung
    1626           0 :     OTableFieldDescRef pEntry = _rInfo;
    1627           0 :     pEntry->SetVisible(bVis);
    1628             : 
    1629             :     // Spalte einfuegen
    1630           0 :     InsertColumn( pEntry, _nColumnPosition );
    1631             : 
    1632           0 :     if ( !m_bInUndoMode )
    1633             :     {
    1634             :         // UndoAction erzeugen
    1635           0 :         OTabFieldCreateUndoAct* pUndoAction = new OTabFieldCreateUndoAct( this );
    1636           0 :         pUndoAction->SetTabFieldDescr( pEntry );
    1637           0 :         pUndoAction->SetColumnPosition(_nColumnPosition);
    1638           0 :         getDesignView()->getController().addUndoActionAndInvalidate( pUndoAction );
    1639             :     }
    1640             : 
    1641           0 :     return pEntry;
    1642             : }
    1643             : 
    1644             : //------------------------------------------------------------------------------
    1645           0 : sal_uInt16 OSelectionBrowseBox::FieldsCount()
    1646             : {
    1647             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1648           0 :     OTableFields::iterator aIter = getFields().begin();
    1649           0 :     sal_uInt16 nCount = 0;
    1650             : 
    1651           0 :     while (aIter != getFields().end())
    1652             :     {
    1653           0 :         if ((*aIter).is() && !(*aIter)->IsEmpty())
    1654           0 :             ++nCount;
    1655           0 :         ++aIter;
    1656             :     }
    1657             : 
    1658           0 :     return nCount;
    1659             : }
    1660             : 
    1661             : //------------------------------------------------------------------------------
    1662           0 : OTableFieldDescRef OSelectionBrowseBox::FindFirstFreeCol(sal_uInt16& _rColumnPosition )
    1663             : {
    1664             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1665           0 :     OTableFields::iterator aIter = getFields().begin();
    1666           0 :     OTableFields::iterator aEnd  = getFields().end();
    1667             : 
    1668           0 :     _rColumnPosition = BROWSER_INVALIDID;
    1669             : 
    1670           0 :     while ( aIter != aEnd )
    1671             :     {
    1672           0 :         ++_rColumnPosition;
    1673           0 :         OTableFieldDescRef pEntry = (*aIter);
    1674           0 :         if ( pEntry.is() && pEntry->IsEmpty() )
    1675           0 :             return pEntry;
    1676           0 :         ++aIter;
    1677           0 :     }
    1678             : 
    1679           0 :     return NULL;
    1680             : }
    1681             : 
    1682             : //------------------------------------------------------------------------------
    1683           0 : void OSelectionBrowseBox::CheckFreeColumns(sal_uInt16& _rColumnPosition)
    1684             : {
    1685             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1686           0 :     if (FindFirstFreeCol(_rColumnPosition) == NULL)
    1687             :     {
    1688             :         // es ist voll, also einen Packen Spalten anhaengen
    1689           0 :         AppendNewCol(DEFAULT_QUERY_COLS);
    1690           0 :         OSL_VERIFY(FindFirstFreeCol(_rColumnPosition).is());
    1691             :     }
    1692           0 : }
    1693             : //------------------------------------------------------------------------------
    1694           0 : void OSelectionBrowseBox::AddGroupBy( const OTableFieldDescRef& rInfo , sal_uInt32 /*_nCurrentPos*/)
    1695             : {
    1696           0 :     Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
    1697           0 :     if(!xConnection.is())
    1698           0 :         return;
    1699             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1700             :     OSL_ENSURE(!rInfo->IsEmpty(),"AddGroupBy:: OTableFieldDescRef sollte nicht Empty sein!");
    1701           0 :     OTableFieldDescRef pEntry;
    1702           0 :     const Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData();
    1703           0 :     const ::comphelper::UStringMixEqual bCase(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers());
    1704             :     //sal_Bool bAppend = sal_False;
    1705             : 
    1706           0 :     OTableFields& rFields = getFields();
    1707           0 :     OTableFields::iterator aIter = rFields.begin();
    1708           0 :     OTableFields::iterator aEnd = rFields.end();
    1709           0 :     for(;aIter != aEnd;++aIter)
    1710             :     {
    1711           0 :         pEntry = *aIter;
    1712             :         OSL_ENSURE(pEntry.is(),"OTableFieldDescRef was null!");
    1713             : 
    1714           0 :         const ::rtl::OUString   aField = pEntry->GetField();
    1715           0 :         const ::rtl::OUString   aAlias = pEntry->GetAlias();
    1716             : 
    1717           0 :         if (bCase(aField,rInfo->GetField()) &&
    1718           0 :             bCase(aAlias,rInfo->GetAlias()) &&
    1719           0 :             pEntry->GetFunctionType() == rInfo->GetFunctionType() &&
    1720           0 :             pEntry->GetFunction() == rInfo->GetFunction())
    1721             :         {
    1722           0 :             if ( pEntry->isNumericOrAggreateFunction() && rInfo->IsGroupBy() )
    1723             :             {
    1724           0 :                 pEntry->SetGroupBy(sal_False);
    1725           0 :                 aIter = rFields.end();
    1726             :                 break;
    1727             :             }
    1728             :             else
    1729             :             {
    1730           0 :                 if ( !pEntry->IsGroupBy() && !pEntry->HasCriteria() ) // here we have a where condition which is no having clause
    1731             :                 {
    1732           0 :                     pEntry->SetGroupBy(rInfo->IsGroupBy());
    1733           0 :                     if(!m_bGroupByUnRelated && pEntry->IsGroupBy())
    1734           0 :                         pEntry->SetVisible(sal_True);
    1735             :                     break;
    1736             :                 }
    1737             :             }
    1738             : 
    1739             :         }
    1740           0 :     }
    1741             : 
    1742           0 :     if (aIter == rFields.end())
    1743             :     {
    1744           0 :         OTableFieldDescRef pTmp = InsertField(rInfo, BROWSER_INVALIDID, sal_False, sal_False );
    1745           0 :         if ( (pTmp->isNumericOrAggreateFunction() && rInfo->IsGroupBy()) ) // das GroupBy wird bereits von rInfo "ubernommen
    1746           0 :             pTmp->SetGroupBy(sal_False);
    1747           0 :     }
    1748             : }
    1749             : //------------------------------------------------------------------------------
    1750           0 : void OSelectionBrowseBox::DuplicateConditionLevel( const sal_uInt16 nLevel)
    1751             : {
    1752             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1753           0 :     const sal_uInt16 nNewLevel = nLevel +1;
    1754           0 :     OTableFields& rFields = getFields();
    1755           0 :     OTableFields::iterator aIter = rFields.begin();
    1756           0 :     OTableFields::iterator aEnd = rFields.end();
    1757           0 :     for(;aIter != aEnd;++aIter)
    1758             :     {
    1759           0 :         OTableFieldDescRef pEntry = *aIter;
    1760             : 
    1761           0 :         ::rtl::OUString sValue = pEntry->GetCriteria(nLevel);
    1762           0 :         if ( !sValue.isEmpty() )
    1763             :         {
    1764           0 :             pEntry->SetCriteria( nNewLevel, sValue);
    1765           0 :             if ( nNewLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1) )
    1766             :             {
    1767           0 :                 RowInserted( GetRowCount()-1, 1, sal_True );
    1768           0 :                 m_bVisibleRow.push_back(sal_True);
    1769           0 :                 ++m_nVisibleCount;
    1770             :             }
    1771           0 :             m_bVisibleRow[BROW_CRIT1_ROW + nNewLevel] = sal_True;
    1772             :         }
    1773           0 :     }
    1774           0 : }
    1775             : //------------------------------------------------------------------------------
    1776           0 : void OSelectionBrowseBox::AddCondition( const OTableFieldDescRef& rInfo, const String& rValue, const sal_uInt16 nLevel,bool _bAddOrOnOneLine )
    1777             : {
    1778           0 :     Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
    1779           0 :     if(!xConnection.is())
    1780           0 :         return;
    1781             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1782             :     OSL_ENSURE(rInfo.is() && !rInfo->IsEmpty(),"AddCondition:: OTableFieldDescRef sollte nicht Empty sein!");
    1783             : 
    1784           0 :     OTableFieldDescRef pLastEntry;
    1785           0 :     Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData();
    1786           0 :     ::comphelper::UStringMixEqual bCase(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers());
    1787             : 
    1788           0 :     OTableFields& rFields = getFields();
    1789           0 :     OTableFields::iterator aIter = rFields.begin();
    1790           0 :     OTableFields::iterator aEnd = rFields.end();
    1791           0 :     for(;aIter != aEnd;++aIter)
    1792             :     {
    1793           0 :         OTableFieldDescRef pEntry = *aIter;
    1794           0 :         const ::rtl::OUString   aField = pEntry->GetField();
    1795           0 :         const ::rtl::OUString   aAlias = pEntry->GetAlias();
    1796             : 
    1797           0 :         if (bCase(aField,rInfo->GetField()) &&
    1798           0 :             bCase(aAlias,rInfo->GetAlias()) &&
    1799           0 :             pEntry->GetFunctionType() == rInfo->GetFunctionType() &&
    1800           0 :             pEntry->GetFunction() == rInfo->GetFunction() &&
    1801           0 :             pEntry->IsGroupBy() == rInfo->IsGroupBy() )
    1802             :         {
    1803           0 :             if ( pEntry->isNumericOrAggreateFunction() && rInfo->IsGroupBy() )
    1804           0 :                 pEntry->SetGroupBy(sal_False);
    1805             :             else
    1806             :             {
    1807           0 :                 if(!m_bGroupByUnRelated && pEntry->IsGroupBy())
    1808           0 :                     pEntry->SetVisible(sal_True);
    1809             :             }
    1810           0 :             if (pEntry->GetCriteria(nLevel).isEmpty() )
    1811             :             {
    1812           0 :                 pEntry->SetCriteria( nLevel, rValue);
    1813           0 :                 if(nLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1))
    1814             :                 {
    1815           0 :                     RowInserted( GetRowCount()-1, 1, sal_True );
    1816           0 :                     m_bVisibleRow.push_back(sal_True);
    1817           0 :                     ++m_nVisibleCount;
    1818             :                 }
    1819           0 :                 m_bVisibleRow[BROW_CRIT1_ROW + nLevel] = sal_True;
    1820             :                 break;
    1821             :             }
    1822           0 :             if ( _bAddOrOnOneLine )
    1823             :             {
    1824           0 :                 pLastEntry = pEntry;
    1825             :             }
    1826             :         }
    1827           0 :     }
    1828           0 :     if ( pLastEntry.is() )
    1829             :     {
    1830           0 :         String sCriteria = rValue;
    1831           0 :         String sOldCriteria = pLastEntry->GetCriteria( nLevel );
    1832           0 :         if ( sOldCriteria.Len() )
    1833             :         {
    1834           0 :             sCriteria = String(RTL_CONSTASCII_USTRINGPARAM("( "));
    1835           0 :             sCriteria += sOldCriteria;
    1836           0 :             sCriteria += String(RTL_CONSTASCII_USTRINGPARAM(" OR "));
    1837           0 :             sCriteria += rValue;
    1838           0 :             sCriteria += String(RTL_CONSTASCII_USTRINGPARAM(" )"));
    1839             :         }
    1840           0 :         pLastEntry->SetCriteria( nLevel, sCriteria);
    1841           0 :         if(nLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1))
    1842             :         {
    1843           0 :             RowInserted( GetRowCount()-1, 1, sal_True );
    1844           0 :             m_bVisibleRow.push_back(sal_True);
    1845           0 :             ++m_nVisibleCount;
    1846             :         }
    1847           0 :         m_bVisibleRow[BROW_CRIT1_ROW + nLevel] = sal_True;
    1848             :     }
    1849             : 
    1850           0 :     else if (aIter == getFields().end())
    1851             :     {
    1852           0 :         OTableFieldDescRef pTmp = InsertField(rInfo, BROWSER_INVALIDID, sal_False, sal_False );
    1853           0 :         if ( pTmp->isNumericOrAggreateFunction() && rInfo->IsGroupBy() ) // das GroupBy wird bereits von rInfo "ubernommen
    1854           0 :             pTmp->SetGroupBy(sal_False);
    1855           0 :         if ( pTmp.is() )
    1856             :         {
    1857           0 :             pTmp->SetCriteria( nLevel, rValue);
    1858           0 :             if(nLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1))
    1859             :             {
    1860           0 :                 RowInserted( GetRowCount()-1, 1, sal_True );
    1861           0 :                 m_bVisibleRow.push_back(sal_True);
    1862           0 :                 ++m_nVisibleCount;
    1863             :             }
    1864           0 :         }
    1865           0 :     }
    1866             : }
    1867             : 
    1868             : //------------------------------------------------------------------------------
    1869           0 : void OSelectionBrowseBox::AddOrder( const OTableFieldDescRef& rInfo, const EOrderDir eDir, sal_uInt32 _nCurrentPos)
    1870             : {
    1871           0 :     if (_nCurrentPos == 0)
    1872           0 :         m_nLastSortColumn = SORT_COLUMN_NONE;
    1873             : 
    1874           0 :     Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
    1875           0 :     if(!xConnection.is())
    1876           0 :         return;
    1877             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1878             :     OSL_ENSURE(!rInfo->IsEmpty(),"AddOrder:: OTableFieldDescRef should not be Empty!");
    1879           0 :     OTableFieldDescRef pEntry;
    1880           0 :     Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData();
    1881           0 :     ::comphelper::UStringMixEqual bCase(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers());
    1882             : 
    1883           0 :     sal_Bool bAppend = sal_False;
    1884           0 :     OTableFields& rFields = getFields();
    1885           0 :     OTableFields::iterator aIter = rFields.begin();
    1886           0 :     OTableFields::iterator aEnd = rFields.end();
    1887           0 :     for(;aIter != aEnd;++aIter)
    1888             :     {
    1889           0 :         pEntry = *aIter;
    1890           0 :         ::rtl::OUString aField = pEntry->GetField();
    1891           0 :         ::rtl::OUString aAlias = pEntry->GetAlias();
    1892             : 
    1893           0 :         if (bCase(aField,rInfo->GetField()) &&
    1894           0 :             bCase(aAlias,rInfo->GetAlias()))
    1895             :         {
    1896           0 :             sal_uInt32 nPos = aIter - rFields.begin();
    1897           0 :             bAppend = (m_nLastSortColumn != SORT_COLUMN_NONE) && (nPos <= m_nLastSortColumn);
    1898           0 :             if ( bAppend )
    1899           0 :                 aIter = rFields.end();
    1900             :             else
    1901             :             {
    1902           0 :                 if ( !m_bOrderByUnRelated )
    1903           0 :                     pEntry->SetVisible(sal_True);
    1904           0 :                 pEntry->SetOrderDir( eDir );
    1905           0 :                 m_nLastSortColumn = nPos;
    1906             :             }
    1907             :             break;
    1908             :         }
    1909           0 :     }
    1910             : 
    1911           0 :     if (aIter == rFields.end())
    1912             :     {
    1913           0 :         OTableFieldDescRef pTmp = InsertField(rInfo, BROWSER_INVALIDID, sal_False, sal_False );
    1914           0 :         if(pTmp.is())
    1915             :         {
    1916           0 :             m_nLastSortColumn = pTmp->GetColumnId() - 1;
    1917           0 :             if ( !m_bOrderByUnRelated && !bAppend )
    1918           0 :                 pTmp->SetVisible(sal_True);
    1919           0 :             pTmp->SetOrderDir( eDir );
    1920           0 :         }
    1921           0 :     }
    1922             : }
    1923             : 
    1924             : //------------------------------------------------------------------------------
    1925           0 : void OSelectionBrowseBox::ArrangeControls(sal_uInt16& nX, sal_uInt16 nY)
    1926             : {
    1927             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1928           0 :     EditBrowseBox::ArrangeControls(nX, nY);
    1929           0 : }
    1930             : 
    1931             : //------------------------------------------------------------------------------
    1932           0 : sal_Bool OSelectionBrowseBox::Save()
    1933             : {
    1934             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1935           0 :     sal_Bool bRet = sal_True;
    1936           0 :     if (IsModified())
    1937           0 :         bRet = SaveModified();
    1938           0 :     return bRet;
    1939             : }
    1940             : 
    1941             : //------------------------------------------------------------------------------
    1942           0 : void OSelectionBrowseBox::CellModified()
    1943             : {
    1944             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1945           0 :     long nRow = GetRealRow(GetCurRow());
    1946           0 :     switch (nRow)
    1947             :     {
    1948             :         case BROW_VIS_ROW:
    1949             :             {
    1950           0 :                 OTableFieldDescRef  pEntry = getEntry(GetColumnPos(GetCurColumnId()) - 1);
    1951             : 
    1952           0 :                 sal_uInt16 nIdx = m_pOrderCell->GetSelectEntryPos();
    1953           0 :                 if(!m_bOrderByUnRelated && nIdx > 0 &&
    1954             :                     nIdx != sal_uInt16(-1)          &&
    1955           0 :                     !pEntry->IsEmpty()              &&
    1956           0 :                     pEntry->GetOrderDir() != ORDER_NONE)
    1957             :                 {
    1958           0 :                     m_pVisibleCell->GetBox().Check();
    1959           0 :                     pEntry->SetVisible(sal_True);
    1960             :                 }
    1961             :                 else
    1962           0 :                     pEntry->SetVisible(m_pVisibleCell->GetBox().IsChecked());
    1963             :             }
    1964           0 :             break;
    1965             :     }
    1966           0 :     static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
    1967           0 : }
    1968             : 
    1969             : //------------------------------------------------------------------------------
    1970           0 : void OSelectionBrowseBox::Fill()
    1971             : {
    1972             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1973             :     OSL_ENSURE(ColCount() >= 1, "OSelectionBrowseBox::Fill : please call only after inserting the handle column !");
    1974             : 
    1975           0 :     sal_uInt16 nColCount = ColCount() - 1;
    1976           0 :     if (nColCount < DEFAULT_QUERY_COLS)
    1977           0 :         AppendNewCol(DEFAULT_QUERY_COLS - nColCount);
    1978           0 : }
    1979             : 
    1980             : //------------------------------------------------------------------------------
    1981           0 : Size OSelectionBrowseBox::CalcOptimalSize( const Size& _rAvailable )
    1982             : {
    1983           0 :     Size aReturn( _rAvailable.Width(), GetTitleHeight() );
    1984             : 
    1985           0 :     aReturn.Height() += ( m_nVisibleCount ? m_nVisibleCount : 15 ) * GetDataRowHeight();
    1986           0 :     aReturn.Height() += 40; // just some space
    1987             : 
    1988           0 :     return aReturn;
    1989             : }
    1990             : 
    1991             : //------------------------------------------------------------------------------
    1992           0 : void OSelectionBrowseBox::Command(const CommandEvent& rEvt)
    1993             : {
    1994             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    1995           0 :     switch (rEvt.GetCommand())
    1996             :     {
    1997             :         case COMMAND_CONTEXTMENU:
    1998             :         {
    1999           0 :             Point aMenuPos( rEvt.GetMousePosPixel() );
    2000             : 
    2001           0 :             if (!rEvt.IsMouseEvent())
    2002             :             {
    2003           0 :                 if  ( 1 == GetSelectColumnCount() )
    2004             :                 {
    2005             :                     sal_uInt16 nSelId = GetColumnId(
    2006             :                         sal::static_int_cast< sal_uInt16 >(
    2007           0 :                             FirstSelectedColumn() ) );
    2008           0 :                     ::Rectangle aColRect( GetFieldRectPixel( 0, nSelId, sal_False ) );
    2009             : 
    2010           0 :                     aMenuPos = aColRect.TopCenter();
    2011             :                 }
    2012             :                 else
    2013             :                 {
    2014           0 :                     EditBrowseBox::Command(rEvt);
    2015             :                     return;
    2016             :                 }
    2017             :             }
    2018             : 
    2019           0 :             sal_uInt16 nColId = GetColumnId(GetColumnAtXPosPixel( aMenuPos.X() ));
    2020           0 :             long   nRow = GetRowAtYPosPixel( aMenuPos.Y() );
    2021             : 
    2022           0 :             if (nRow < 0 && nColId > HANDLE_ID )
    2023             :             {
    2024           0 :                 if ( !IsColumnSelected( nColId ) )
    2025             :                 {
    2026           0 :                     adjustSelectionMode( sal_True /* clicked onto a header */ , sal_False /* not onto the handle col */ );
    2027           0 :                     SelectColumnId( nColId );
    2028             :                 }
    2029             : 
    2030           0 :                 if (!static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly())
    2031             :                 {
    2032           0 :                     PopupMenu aContextMenu( ModuleRes( RID_QUERYCOLPOPUPMENU ) );
    2033           0 :                     switch (aContextMenu.Execute(this, aMenuPos))
    2034             :                     {
    2035             :                         case SID_DELETE:
    2036           0 :                             RemoveField(nColId);
    2037           0 :                             break;
    2038             : 
    2039             :                         case ID_BROWSER_COLWIDTH:
    2040           0 :                             adjustBrowseBoxColumnWidth( this, nColId );
    2041           0 :                             break;
    2042           0 :                     }
    2043           0 :                 }
    2044             :             }
    2045           0 :             else if(nRow >= 0 && nColId <= HANDLE_ID)
    2046             :             {
    2047           0 :                 if (!static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly())
    2048             :                 {
    2049           0 :                     PopupMenu aContextMenu(ModuleRes(RID_QUERYFUNCTION_POPUPMENU));
    2050           0 :                     aContextMenu.CheckItem( ID_QUERY_FUNCTION, m_bVisibleRow[BROW_FUNCTION_ROW]);
    2051           0 :                     aContextMenu.CheckItem( ID_QUERY_TABLENAME, m_bVisibleRow[BROW_TABLE_ROW]);
    2052           0 :                     aContextMenu.CheckItem( ID_QUERY_ALIASNAME, m_bVisibleRow[BROW_COLUMNALIAS_ROW]);
    2053           0 :                     aContextMenu.CheckItem( ID_QUERY_DISTINCT, static_cast<OQueryController&>(getDesignView()->getController()).isDistinct());
    2054             : 
    2055           0 :                     switch (aContextMenu.Execute(this, aMenuPos))
    2056             :                     {
    2057             :                         case ID_QUERY_FUNCTION:
    2058           0 :                             SetRowVisible(BROW_FUNCTION_ROW, !IsRowVisible(BROW_FUNCTION_ROW));
    2059           0 :                             static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_VIEW_FUNCTIONS );
    2060           0 :                             break;
    2061             :                         case ID_QUERY_TABLENAME:
    2062           0 :                             SetRowVisible(BROW_TABLE_ROW, !IsRowVisible(BROW_TABLE_ROW));
    2063           0 :                             static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_VIEW_TABLES );
    2064           0 :                             break;
    2065             :                         case ID_QUERY_ALIASNAME:
    2066           0 :                             SetRowVisible(BROW_COLUMNALIAS_ROW, !IsRowVisible(BROW_COLUMNALIAS_ROW));
    2067           0 :                             static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_VIEW_ALIASES );
    2068           0 :                             break;
    2069             :                         case ID_QUERY_DISTINCT:
    2070           0 :                             static_cast<OQueryController&>(getDesignView()->getController()).setDistinct(!static_cast<OQueryController&>(getDesignView()->getController()).isDistinct());
    2071           0 :                             static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
    2072           0 :                             static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_DISTINCT_VALUES );
    2073           0 :                             break;
    2074             :                     }
    2075             : 
    2076           0 :                     static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
    2077           0 :                 }
    2078             :             }
    2079             :             else
    2080             :             {
    2081           0 :                 EditBrowseBox::Command(rEvt);
    2082             :                 return;
    2083             :             }
    2084             :         }
    2085             :         default:
    2086           0 :             EditBrowseBox::Command(rEvt);
    2087             :     }
    2088             : }
    2089             : 
    2090             : //------------------------------------------------------------------------------
    2091           0 : sal_Bool OSelectionBrowseBox::IsRowVisible(sal_uInt16 _nWhich) const
    2092             : {
    2093             :     OSL_ENSURE(_nWhich<(m_bVisibleRow.size()), "OSelectionBrowseBox::IsRowVisible : invalid parameter !");
    2094           0 :     return m_bVisibleRow[_nWhich];
    2095             : }
    2096             : 
    2097             : //------------------------------------------------------------------------------
    2098           0 : void OSelectionBrowseBox::SetRowVisible(sal_uInt16 _nWhich, sal_Bool _bVis)
    2099             : {
    2100             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    2101             :     OSL_ENSURE(_nWhich<m_bVisibleRow.size(), "OSelectionBrowseBox::SetRowVisible : invalid parameter !");
    2102             : 
    2103           0 :     sal_Bool bWasEditing = IsEditing();
    2104           0 :     if (bWasEditing)
    2105           0 :         DeactivateCell();
    2106             : 
    2107             :     // do this before removing or inserting rows, as this triggers ActivateCell-calls, which rely on m_bVisibleRow
    2108           0 :     m_bVisibleRow[_nWhich] = !m_bVisibleRow[_nWhich];
    2109             : 
    2110           0 :     long nId = GetBrowseRow(_nWhich);
    2111           0 :     if (_bVis)
    2112             :     {
    2113           0 :         RowInserted(nId,1);
    2114           0 :         ++m_nVisibleCount;
    2115             :     }
    2116             :     else
    2117             :     {
    2118           0 :         RowRemoved(nId,1);
    2119           0 :         --m_nVisibleCount;
    2120             :     }
    2121             : 
    2122           0 :     if (bWasEditing)
    2123           0 :         ActivateCell();
    2124           0 : }
    2125             : 
    2126             : //------------------------------------------------------------------------------
    2127           0 : long OSelectionBrowseBox::GetBrowseRow(long nRowId) const
    2128             : {
    2129           0 :     sal_uInt16 nCount(0);
    2130           0 :     for(sal_uInt16 i = 0 ; i < nRowId ; ++i)
    2131             :     {
    2132           0 :         if ( m_bVisibleRow[i] )
    2133           0 :             ++nCount;
    2134             :     }
    2135           0 :     return nCount;
    2136             : }
    2137             : //------------------------------------------------------------------------------
    2138           0 : long OSelectionBrowseBox::GetRealRow(long nRowId) const
    2139             : {
    2140             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    2141           0 :     long nErg=0,i;
    2142           0 :     const long nCount = m_bVisibleRow.size();
    2143           0 :     for(i=0;i < nCount; ++i)
    2144             :     {
    2145           0 :         if(m_bVisibleRow[i])
    2146             :         {
    2147           0 :             if(nErg++ == nRowId)
    2148           0 :                 break;
    2149             :         }
    2150             :     }
    2151             :     OSL_ENSURE(nErg <= long(m_bVisibleRow.size()),"nErg kann nicht groesser als BROW_ROW_CNT sein!");
    2152           0 :     return i;
    2153             : }
    2154             : static long nVisibleRowMask[] =
    2155             :                     {
    2156             :                             0x0001,
    2157             :                             0x0002,
    2158             :                             0x0004,
    2159             :                             0x0008,
    2160             :                             0x0010,
    2161             :                             0x0020,
    2162             :                             0x0040,
    2163             :                             0x0080,
    2164             :                             0x0100,
    2165             :                             0x0200,
    2166             :                             0x0400,
    2167             :                             0x0800
    2168             :                     };
    2169             : //------------------------------------------------------------------------------
    2170           0 : sal_Int32 OSelectionBrowseBox::GetNoneVisibleRows() const
    2171             : {
    2172           0 :     sal_Int32 nErg(0);
    2173             :     // only the first 11 row are interesting
    2174           0 :     sal_Int32 nSize = sizeof(nVisibleRowMask) / sizeof(nVisibleRowMask[0]);
    2175           0 :     for(sal_Int32 i=0;i<nSize;i++)
    2176             :     {
    2177           0 :         if(!m_bVisibleRow[i])
    2178           0 :             nErg |= nVisibleRowMask[i];
    2179             :     }
    2180           0 :     return nErg;
    2181             : }
    2182             : //------------------------------------------------------------------------------
    2183           0 : void OSelectionBrowseBox::SetNoneVisbleRow(long nRows)
    2184             : {
    2185             :     // only the first 11 row are interesting
    2186           0 :     sal_Int32 nSize = sizeof(nVisibleRowMask) / sizeof(nVisibleRowMask[0]);
    2187           0 :     for(sal_Int32 i=0;i< nSize;i++)
    2188           0 :         m_bVisibleRow[i] = !(nRows & nVisibleRowMask[i]);
    2189           0 : }
    2190             : //------------------------------------------------------------------------------
    2191           0 : String OSelectionBrowseBox::GetCellText(long nRow, sal_uInt16 nColId) const
    2192             : {
    2193             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    2194             : 
    2195           0 :     sal_uInt16 nPos = GetColumnPos(nColId);
    2196             : 
    2197           0 :     OTableFieldDescRef pEntry = getFields()[nPos-1];
    2198             :     OSL_ENSURE(pEntry != NULL, "OSelectionBrowseBox::GetCellText : invalid column id, prepare for GPF ... ");
    2199           0 :     if ( pEntry->IsEmpty() )
    2200           0 :         return String();
    2201             : 
    2202           0 :     String aText;
    2203           0 :     switch (nRow)
    2204             :     {
    2205             :         case BROW_TABLE_ROW:
    2206           0 :             aText = pEntry->GetAlias();
    2207           0 :             break;
    2208             :         case BROW_FIELD_ROW:
    2209             :         {
    2210           0 :             String aField = pEntry->GetField();
    2211           0 :             if (aField.GetChar(0) == '*')                   // * durch alias.* ersetzen
    2212             :             {
    2213           0 :                 aField = pEntry->GetAlias();
    2214           0 :                 if(aField.Len())
    2215           0 :                     aField += '.';
    2216           0 :                 aField += '*';
    2217             :             }
    2218           0 :             aText = aField;
    2219           0 :         }   break;
    2220             :         case BROW_ORDER_ROW:
    2221           0 :             if (pEntry->GetOrderDir() != ORDER_NONE)
    2222           0 :                 aText = String(ModuleRes(STR_QUERY_SORTTEXT) ).GetToken(sal::static_int_cast< sal_uInt16 >(pEntry->GetOrderDir()));
    2223           0 :             break;
    2224             :         case BROW_VIS_ROW:
    2225           0 :             break;
    2226             :         case BROW_COLUMNALIAS_ROW:
    2227           0 :             aText = pEntry->GetFieldAlias();
    2228           0 :             break;
    2229             :         case BROW_FUNCTION_ROW:
    2230             :             // we always show the group function at first
    2231           0 :             if ( pEntry->IsGroupBy() )
    2232           0 :                 aText = m_aFunctionStrings.GetToken(comphelper::string::getTokenCount(m_aFunctionStrings, ';')-1);
    2233           0 :             else if ( pEntry->isNumericOrAggreateFunction() )
    2234           0 :                 aText = pEntry->GetFunction();
    2235           0 :             break;
    2236             :         default:
    2237           0 :             aText = pEntry->GetCriteria(sal_uInt16(nRow - BROW_CRIT1_ROW));
    2238             :     }
    2239           0 :     return aText;
    2240             : }
    2241             : //------------------------------------------------------------------------------
    2242           0 : sal_Bool OSelectionBrowseBox::GetFunctionName(sal_uInt32 _nFunctionTokenId,String& rFkt)
    2243             : {
    2244             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    2245           0 :     sal_Bool bErg=sal_True;
    2246           0 :     String aText;
    2247           0 :     switch(_nFunctionTokenId)
    2248             :     {
    2249             :         case SQL_TOKEN_COUNT:
    2250           0 :             rFkt = (m_pFunctionCell->GetEntryCount() < 3) ? m_pFunctionCell->GetEntry(1) : m_pFunctionCell->GetEntry(2);
    2251           0 :             break;
    2252             :         case SQL_TOKEN_AVG:
    2253           0 :             rFkt = m_pFunctionCell->GetEntry(1);
    2254           0 :             break;
    2255             :         case SQL_TOKEN_MAX:
    2256           0 :             rFkt = m_pFunctionCell->GetEntry(3);
    2257           0 :             break;
    2258             :         case SQL_TOKEN_MIN:
    2259           0 :             rFkt = m_pFunctionCell->GetEntry(4);
    2260           0 :             break;
    2261             :         case SQL_TOKEN_SUM:
    2262           0 :             rFkt = m_pFunctionCell->GetEntry(5);
    2263           0 :             break;
    2264             :         case SQL_TOKEN_EVERY:
    2265           0 :             rFkt = m_pFunctionCell->GetEntry(6);
    2266           0 :             break;
    2267             :         case SQL_TOKEN_ANY:
    2268           0 :             rFkt = m_pFunctionCell->GetEntry(7);
    2269           0 :             break;
    2270             :         case SQL_TOKEN_SOME:
    2271           0 :             rFkt = m_pFunctionCell->GetEntry(8);
    2272           0 :             break;
    2273             :         case SQL_TOKEN_STDDEV_POP:
    2274           0 :             rFkt = m_pFunctionCell->GetEntry(9);
    2275           0 :             break;
    2276             :         case SQL_TOKEN_STDDEV_SAMP:
    2277           0 :             rFkt = m_pFunctionCell->GetEntry(10);
    2278           0 :             break;
    2279             :         case SQL_TOKEN_VAR_SAMP:
    2280           0 :             rFkt = m_pFunctionCell->GetEntry(11);
    2281           0 :             break;
    2282             :         case SQL_TOKEN_VAR_POP:
    2283           0 :             rFkt = m_pFunctionCell->GetEntry(12);
    2284           0 :             break;
    2285             :         case SQL_TOKEN_COLLECT:
    2286           0 :             rFkt = m_pFunctionCell->GetEntry(13);
    2287           0 :             break;
    2288             :         case SQL_TOKEN_FUSION:
    2289           0 :             rFkt = m_pFunctionCell->GetEntry(14);
    2290           0 :             break;
    2291             :         case SQL_TOKEN_INTERSECTION:
    2292           0 :             rFkt = m_pFunctionCell->GetEntry(15);
    2293           0 :             break;
    2294             :         default:
    2295             :             {
    2296           0 :                 xub_StrLen nCount = comphelper::string::getTokenCount(m_aFunctionStrings, ';');
    2297             :                 xub_StrLen i;
    2298           0 :                 for ( i = 0; i < nCount-1; i++) // Gruppierung wird nicht mit gez"ahlt
    2299             :                 {
    2300           0 :                     if(rFkt.EqualsIgnoreCaseAscii(m_aFunctionStrings.GetToken(i)))
    2301             :                     {
    2302           0 :                         rFkt = m_aFunctionStrings.GetToken(i);
    2303           0 :                         break;
    2304             :                     }
    2305             :                 }
    2306           0 :                 if(i == nCount-1)
    2307           0 :                     bErg = sal_False;
    2308             :             }
    2309             :     }
    2310             : 
    2311           0 :     return bErg;
    2312             : }
    2313             : //------------------------------------------------------------------------------
    2314           0 : String OSelectionBrowseBox::GetCellContents(sal_Int32 nCellIndex, sal_uInt16 nColId)
    2315             : {
    2316             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    2317           0 :     if ( GetCurColumnId() == nColId && !m_bInUndoMode )
    2318           0 :         SaveModified();
    2319             : 
    2320           0 :     sal_uInt16 nPos = GetColumnPos(nColId);
    2321           0 :     OTableFieldDescRef pEntry = getFields()[nPos - 1];
    2322             :     OSL_ENSURE(pEntry != NULL, "OSelectionBrowseBox::GetCellContents : invalid column id, prepare for GPF ... ");
    2323             : 
    2324           0 :     switch (nCellIndex)
    2325             :     {
    2326             :         case BROW_VIS_ROW :
    2327           0 :             return pEntry->IsVisible() ? g_strOne : g_strZero;
    2328             :         case BROW_ORDER_ROW:
    2329             :         {
    2330           0 :             sal_uInt16 nIdx = m_pOrderCell->GetSelectEntryPos();
    2331           0 :             if (nIdx == sal_uInt16(-1))
    2332           0 :                 nIdx = 0;
    2333           0 :             return rtl::OUString(nIdx);
    2334             :         }
    2335             :         default:
    2336           0 :             return GetCellText(nCellIndex, nColId);
    2337           0 :     }
    2338             : }
    2339             : 
    2340             : //------------------------------------------------------------------------------
    2341           0 : void OSelectionBrowseBox::SetCellContents(sal_Int32 nRow, sal_uInt16 nColId, const String& strNewText)
    2342             : {
    2343             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    2344           0 :     sal_Bool bWasEditing = IsEditing() && (GetCurColumnId() == nColId) && IsRowVisible(static_cast<sal_uInt16>(nRow)) && (GetCurRow() == static_cast<sal_uInt16>(GetBrowseRow(nRow)));
    2345           0 :     if (bWasEditing)
    2346           0 :         DeactivateCell();
    2347             : 
    2348           0 :     sal_uInt16 nPos = GetColumnPos(nColId);
    2349           0 :     OTableFieldDescRef pEntry = getEntry(nPos - 1);
    2350             :     OSL_ENSURE(pEntry != NULL, "OSelectionBrowseBox::SetCellContents : invalid column id, prepare for GPF ... ");
    2351             : 
    2352             : 
    2353           0 :     switch (nRow)
    2354             :     {
    2355             :         case BROW_VIS_ROW:
    2356           0 :             pEntry->SetVisible(strNewText.Equals(g_strOne));
    2357           0 :             break;
    2358             :         case BROW_FIELD_ROW:
    2359           0 :             pEntry->SetField(strNewText);
    2360           0 :             break;
    2361             :         case BROW_TABLE_ROW:
    2362           0 :             pEntry->SetAlias(strNewText);
    2363           0 :             break;
    2364             :         case BROW_ORDER_ROW:
    2365             :         {
    2366           0 :             sal_uInt16 nIdx = (sal_uInt16)strNewText.ToInt32();
    2367           0 :             pEntry->SetOrderDir(EOrderDir(nIdx));
    2368           0 :         }   break;
    2369             :         case BROW_COLUMNALIAS_ROW:
    2370           0 :             pEntry->SetFieldAlias(strNewText);
    2371           0 :             break;
    2372             :         case BROW_FUNCTION_ROW:
    2373             :         {
    2374           0 :             String sOldFunctionName   = pEntry->GetFunction();
    2375           0 :             String sGroupFunctionName = m_aFunctionStrings.GetToken(comphelper::string::getTokenCount(m_aFunctionStrings, ';')-1);
    2376           0 :             pEntry->SetFunction(strNewText);
    2377             :             // first reset this two member
    2378           0 :             sal_Int32 nFunctionType = pEntry->GetFunctionType();
    2379           0 :             nFunctionType &= ~FKT_AGGREGATE;
    2380           0 :             pEntry->SetFunctionType(nFunctionType);
    2381           0 :             if ( pEntry->IsGroupBy() && !sGroupFunctionName.EqualsIgnoreCaseAscii(strNewText) )
    2382           0 :                 pEntry->SetGroupBy(sal_False);
    2383             : 
    2384             : 
    2385           0 :             if ( sGroupFunctionName.EqualsIgnoreCaseAscii(strNewText) )
    2386           0 :                 pEntry->SetGroupBy(sal_True);
    2387           0 :             else if ( strNewText.Len() )
    2388             :             {
    2389           0 :                 nFunctionType |= FKT_AGGREGATE;
    2390           0 :                 pEntry->SetFunctionType(nFunctionType);
    2391           0 :             }
    2392           0 :         }   break;
    2393             :         default:
    2394           0 :             pEntry->SetCriteria(sal_uInt16(nRow - BROW_CRIT1_ROW), strNewText);
    2395             :     }
    2396             : 
    2397           0 :     long nCellIndex = GetRealRow(nRow);
    2398           0 :     if(IsRowVisible(static_cast<sal_uInt16>(nRow)))
    2399           0 :         RowModified(nCellIndex, nColId);
    2400             : 
    2401             :     // die entsprechende Feld-Beschreibung ist jetzt leer -> Visible auf sal_False (damit das konsistent mit normalen leeren Spalten ist)
    2402           0 :     if (pEntry->IsEmpty())
    2403           0 :         pEntry->SetVisible(sal_False);
    2404             : 
    2405           0 :     if (bWasEditing)
    2406           0 :         ActivateCell(nCellIndex, nColId);
    2407             : 
    2408           0 :     static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
    2409           0 : }
    2410             : //------------------------------------------------------------------------------
    2411           0 : sal_uInt32 OSelectionBrowseBox::GetTotalCellWidth(long nRow, sal_uInt16 nColId) const
    2412             : {
    2413             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    2414             : 
    2415           0 :     long nRowId = GetRealRow(nRow);
    2416           0 :     if (nRowId == BROW_VIS_ROW)
    2417           0 :         return CHECKBOX_SIZE;
    2418             :     else
    2419           0 :         return  GetDataWindow().GetTextWidth(GetCellText(nRowId, nColId));
    2420             : }
    2421             : 
    2422             : //------------------------------------------------------------------------------
    2423           0 : void OSelectionBrowseBox::ColumnResized(sal_uInt16 nColId)
    2424             : {
    2425           0 :     if (static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly())
    2426           0 :         return;
    2427             :     // The resizing of columns can't be suppressed (BrowseBox doesn't support that) so we have to do this
    2428             :     // fake. It's not _that_ bad : the user may change column widths while in read-only mode to see all details
    2429             :     // but the changes aren't permanent ...
    2430             : 
    2431             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    2432           0 :     sal_uInt16 nPos = GetColumnPos(nColId);
    2433             :     OSL_ENSURE(nPos <= getFields().size(),"ColumnResized:: nColId sollte nicht groesser als List::count sein!");
    2434           0 :     OTableFieldDescRef pEntry = getEntry(nPos-1);
    2435             :     OSL_ENSURE(pEntry.is(), "OSelectionBrowseBox::ColumnResized : keine FieldDescription !");
    2436           0 :     static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True );
    2437           0 :     EditBrowseBox::ColumnResized(nColId);
    2438             : 
    2439           0 :     if ( pEntry.is())
    2440             :     {
    2441           0 :         if ( !m_bInUndoMode )
    2442             :         {
    2443             :             // create the undo action
    2444           0 :             OTabFieldSizedUndoAct* pUndo = new OTabFieldSizedUndoAct(this);
    2445           0 :             pUndo->SetColumnPosition( nPos );
    2446           0 :             pUndo->SetOriginalWidth(pEntry->GetColWidth());
    2447           0 :             getDesignView()->getController().addUndoActionAndInvalidate(pUndo);
    2448             :         }
    2449           0 :         pEntry->SetColWidth(sal_uInt16(GetColumnWidth(nColId)));
    2450           0 :     }
    2451             : }
    2452             : 
    2453             : //------------------------------------------------------------------------------
    2454           0 : sal_uInt32 OSelectionBrowseBox::GetTotalCellWidth(long nRowId, sal_uInt16 nColId)
    2455             : {
    2456             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    2457           0 :     sal_uInt16 nPos = GetColumnPos(nColId);
    2458             :     OSL_ENSURE((nPos == 0) || (nPos <= getFields().size()), "OSelectionBrowseBox::GetTotalCellWidth : invalid parameter nColId");
    2459             : 
    2460           0 :     OTableFieldDescRef pEntry = getFields()[nPos-1];
    2461             :     OSL_ENSURE(pEntry.is(), "OSelectionBrowseBox::GetTotalCellWidth : invalid FieldDescription !");
    2462             : 
    2463           0 :     long nRow = GetRealRow(nRowId);
    2464           0 :     String strText(GetCellText(nRow, nColId));
    2465           0 :     return GetDataWindow().LogicToPixel(Size(GetDataWindow().GetTextWidth(strText),0)).Width();
    2466             : }
    2467             : 
    2468             : //------------------------------------------------------------------------------
    2469           0 : sal_uInt16 OSelectionBrowseBox::GetDefaultColumnWidth(const String& /*rName*/) const
    2470             : {
    2471             :     DBG_CHKTHIS(OSelectionBrowseBox,NULL);
    2472             :     // die Baissklasse macht das von dem Text abhaengig, ich habe aber keine Spaltenueberschriften, daher haette ich
    2473             :     // hier gern einen anderen Default-Wert
    2474           0 :     return static_cast<sal_uInt16>(DEFAULT_SIZE);
    2475             : }
    2476             : //------------------------------------------------------------------------------
    2477           0 : sal_Bool OSelectionBrowseBox::isCutAllowed()
    2478             : {
    2479           0 :     sal_Bool bCutAllowed = sal_False;
    2480           0 :     long nRow = GetRealRow(GetCurRow());
    2481           0 :     switch (nRow)
    2482             :     {
    2483             :         case BROW_VIS_ROW:
    2484             :         case BROW_ORDER_ROW:
    2485             :         case BROW_TABLE_ROW:
    2486             :         case BROW_FUNCTION_ROW:
    2487           0 :             break;
    2488             :         case BROW_FIELD_ROW:
    2489           0 :             bCutAllowed = m_pFieldCell->GetSelected().Len() != 0;
    2490           0 :             break;
    2491             :         default:
    2492           0 :             bCutAllowed = m_pTextCell->GetSelected().Len() != 0;
    2493           0 :             break;
    2494             :     }
    2495           0 :     return bCutAllowed;
    2496             : }
    2497             : // -----------------------------------------------------------------------------
    2498           0 : void OSelectionBrowseBox::cut()
    2499             : {
    2500           0 :     String sOldValue = GetCellContents(GetRealRow(GetCurRow()),GetCurColumnId());
    2501           0 :     long nRow = GetRealRow(GetCurRow());
    2502           0 :     switch (nRow)
    2503             :     {
    2504             :         case BROW_FIELD_ROW:
    2505           0 :             m_pFieldCell->Cut();
    2506           0 :             m_pFieldCell->SetModifyFlag();
    2507           0 :             break;
    2508             :         default:
    2509           0 :             m_pTextCell->Cut();
    2510           0 :             m_pTextCell->SetModifyFlag();
    2511             :     }
    2512           0 :     SaveModified();
    2513           0 :     RowModified(GetBrowseRow(nRow), GetCurColumnId());
    2514             : 
    2515           0 :     invalidateUndoRedo();
    2516           0 : }
    2517             : // -----------------------------------------------------------------------------
    2518           0 : void OSelectionBrowseBox::paste()
    2519             : {
    2520           0 :     long nRow = GetRealRow(GetCurRow());
    2521           0 :     switch (nRow)
    2522             :     {
    2523             :         case BROW_FIELD_ROW:
    2524           0 :             m_pFieldCell->Paste();
    2525           0 :             m_pFieldCell->SetModifyFlag();
    2526           0 :             break;
    2527             :         default:
    2528           0 :             m_pTextCell->Paste();
    2529           0 :             m_pTextCell->SetModifyFlag();
    2530             :     }
    2531           0 :     RowModified(GetBrowseRow(nRow), GetCurColumnId());
    2532           0 :     invalidateUndoRedo();
    2533           0 : }
    2534             : // -----------------------------------------------------------------------------
    2535           0 : sal_Bool OSelectionBrowseBox::isPasteAllowed()
    2536             : {
    2537           0 :     sal_Bool bPasteAllowed = sal_True;
    2538           0 :     long nRow = GetRealRow(GetCurRow());
    2539           0 :     switch (nRow)
    2540             :     {
    2541             :         case BROW_VIS_ROW:
    2542             :         case BROW_ORDER_ROW:
    2543             :         case BROW_TABLE_ROW:
    2544             :         case BROW_FUNCTION_ROW:
    2545           0 :             bPasteAllowed = sal_False;
    2546           0 :             break;
    2547             :     }
    2548           0 :     return bPasteAllowed;
    2549             : }
    2550             : // -----------------------------------------------------------------------------
    2551           0 : sal_Bool OSelectionBrowseBox::isCopyAllowed()
    2552             : {
    2553           0 :     return isCutAllowed();
    2554             : }
    2555             : // -----------------------------------------------------------------------------
    2556           0 : void OSelectionBrowseBox::copy()
    2557             : {
    2558           0 :     long nRow = GetRealRow(GetCurRow());
    2559           0 :     switch (nRow)
    2560             :     {
    2561             :         case BROW_FIELD_ROW:
    2562           0 :             m_pFieldCell->Copy();
    2563           0 :             break;
    2564             :         default:
    2565           0 :             m_pTextCell->Copy();
    2566             :     }
    2567           0 : }
    2568             : // -----------------------------------------------------------------------------
    2569           0 : void OSelectionBrowseBox::appendUndoAction(const String& _rOldValue,const String& _rNewValue,sal_Int32 _nRow,sal_Bool& _bListAction)
    2570             : {
    2571           0 :     if ( !m_bInUndoMode && !_rNewValue.Equals(_rOldValue) )
    2572             :     {
    2573           0 :         if ( !_bListAction )
    2574             :         {
    2575           0 :             _bListAction = sal_True;
    2576           0 :             static_cast<OQueryController&>(getDesignView()->getController()).GetUndoManager().EnterListAction(String(),String());
    2577             :         }
    2578           0 :         appendUndoAction(_rOldValue,_rNewValue,_nRow);
    2579             :     }
    2580           0 : }
    2581             : // -----------------------------------------------------------------------------
    2582           0 : void OSelectionBrowseBox::appendUndoAction(const String& _rOldValue,const String& _rNewValue,sal_Int32 _nRow)
    2583             : {
    2584           0 :     if ( !m_bInUndoMode && !_rNewValue.Equals(_rOldValue) )
    2585             :     {
    2586           0 :         OTabFieldCellModifiedUndoAct* pUndoAct = new OTabFieldCellModifiedUndoAct(this);
    2587           0 :         pUndoAct->SetCellIndex(_nRow);
    2588             :         OSL_ENSURE(GetColumnPos(GetCurColumnId()) != BROWSER_INVALIDID,"Current position isn't valid!");
    2589           0 :         pUndoAct->SetColumnPosition( GetColumnPos(GetCurColumnId()) );
    2590           0 :         pUndoAct->SetCellContents(_rOldValue);
    2591           0 :         getDesignView()->getController().addUndoActionAndInvalidate(pUndoAct);
    2592             :     }
    2593           0 : }
    2594             : // -----------------------------------------------------------------------------
    2595           0 : IMPL_LINK_NOARG(OSelectionBrowseBox, OnInvalidateTimer)
    2596             : {
    2597           0 :     static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature(SID_CUT);
    2598           0 :     static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature(SID_COPY);
    2599           0 :     static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature(SID_PASTE);
    2600           0 :     if(!m_bStopTimer)
    2601           0 :         m_timerInvalidate.Start();
    2602           0 :     return 0L;
    2603             : }
    2604             : // -----------------------------------------------------------------------------
    2605           0 : void OSelectionBrowseBox::stopTimer()
    2606             : {
    2607           0 :     m_bStopTimer = sal_True;
    2608           0 :     if (m_timerInvalidate.IsActive())
    2609           0 :         m_timerInvalidate.Stop();
    2610           0 : }
    2611             : // -----------------------------------------------------------------------------
    2612           0 : void OSelectionBrowseBox::startTimer()
    2613             : {
    2614           0 :     m_bStopTimer = sal_False;
    2615           0 :     if (!m_timerInvalidate.IsActive())
    2616           0 :         m_timerInvalidate.Start();
    2617           0 : }
    2618             : // -----------------------------------------------------------------------------
    2619           0 : OTableFields& OSelectionBrowseBox::getFields() const
    2620             : {
    2621           0 :     OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
    2622           0 :     return rController.getTableFieldDesc();
    2623             : }
    2624             : // -----------------------------------------------------------------------------
    2625           0 : void OSelectionBrowseBox::enableControl(const OTableFieldDescRef& _rEntry,Window* _pControl)
    2626             : {
    2627           0 :     sal_Bool bEnable = !_rEntry->isCondition();
    2628           0 :     _pControl->Enable(bEnable);
    2629           0 :     _pControl->EnableInput(bEnable);
    2630           0 : }
    2631             : // -----------------------------------------------------------------------------
    2632           0 : void OSelectionBrowseBox::setTextCellContext(const OTableFieldDescRef& _rEntry,const String& _sText,const rtl::OString& _sHelpId)
    2633             : {
    2634           0 :     m_pTextCell->SetText(_sText);
    2635           0 :     m_pTextCell->ClearModifyFlag();
    2636           0 :     if (!m_pTextCell->HasFocus())
    2637           0 :         m_pTextCell->GrabFocus();
    2638             : 
    2639           0 :     enableControl(_rEntry,m_pTextCell);
    2640             : 
    2641           0 :     if (m_pTextCell->GetHelpId() != _sHelpId)
    2642             :         // da TextCell in verschiedenen Kontexten verwendet wird, muss ich den gecachten HelpText loeschen
    2643           0 :         m_pTextCell->SetHelpText(String());
    2644           0 :     m_pTextCell->SetHelpId(_sHelpId);
    2645           0 : }
    2646             : // -----------------------------------------------------------------------------
    2647           0 : void OSelectionBrowseBox::invalidateUndoRedo()
    2648             : {
    2649           0 :     OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController());
    2650           0 :     rController.InvalidateFeature( ID_BROWSER_UNDO );
    2651           0 :     rController.InvalidateFeature( ID_BROWSER_REDO );
    2652           0 :     rController.InvalidateFeature( ID_BROWSER_QUERY_EXECUTE );
    2653           0 : }
    2654             : // -----------------------------------------------------------------------------
    2655           0 : OTableFieldDescRef OSelectionBrowseBox::getEntry(OTableFields::size_type _nPos)
    2656             : {
    2657             :     // we have to check if we need a new entry at this position
    2658           0 :     OTableFields& aFields = getFields();
    2659             :     OSL_ENSURE(aFields.size() > _nPos,"ColID is to great!");
    2660             : 
    2661           0 :     OTableFieldDescRef pEntry = aFields[_nPos];
    2662             :     OSL_ENSURE(pEntry.is(),"Invalid entry!");
    2663           0 :     if ( !pEntry.is() )
    2664             :     {
    2665           0 :         pEntry = new OTableFieldDesc();
    2666             :         pEntry->SetColumnId(
    2667           0 :             GetColumnId(sal::static_int_cast< sal_uInt16 >(_nPos+1)));
    2668           0 :         aFields[_nPos] = pEntry;
    2669             :     }
    2670           0 :     return pEntry;
    2671             : }
    2672             : // -----------------------------------------------------------------------------
    2673           0 : void OSelectionBrowseBox::GetFocus()
    2674             : {
    2675           0 :     if(!IsEditing() && !m_bWasEditing)
    2676           0 :         ActivateCell();
    2677           0 :     EditBrowseBox::GetFocus();
    2678           0 : }
    2679             : // -----------------------------------------------------------------------------
    2680           0 : void OSelectionBrowseBox::DeactivateCell(sal_Bool _bUpdate)
    2681             : {
    2682           0 :     m_bWasEditing = sal_True;
    2683           0 :     EditBrowseBox::DeactivateCell(_bUpdate);
    2684           0 :     m_bWasEditing = sal_False;
    2685           0 : }
    2686             : // -----------------------------------------------------------------------------
    2687           0 : ::rtl::OUString OSelectionBrowseBox::GetRowDescription( sal_Int32 _nRow ) const
    2688             : {
    2689           0 :     String  aLabel(ModuleRes(STR_QUERY_HANDLETEXT));
    2690             : 
    2691             :     // ab BROW_CRIT2_ROW werden alle Zeilen mit "oder" angegeben
    2692           0 :     xub_StrLen nToken = (xub_StrLen) (_nRow >= GetBrowseRow(BROW_CRIT2_ROW))
    2693             :                                 ?
    2694           0 :             xub_StrLen(BROW_CRIT2_ROW) : xub_StrLen(GetRealRow(_nRow));
    2695           0 :     return ::rtl::OUString(aLabel.GetToken(nToken));
    2696             : }
    2697             : // -----------------------------------------------------------------------------
    2698           0 : ::rtl::OUString OSelectionBrowseBox::GetAccessibleObjectName( ::svt::AccessibleBrowseBoxObjType _eObjType,sal_Int32 _nPosition) const
    2699             : {
    2700           0 :     ::rtl::OUString sRetText;
    2701           0 :     switch( _eObjType )
    2702             :     {
    2703             :         case ::svt::BBTYPE_ROWHEADERCELL:
    2704           0 :             sRetText = GetRowDescription(_nPosition);
    2705           0 :             break;
    2706             :         default:
    2707           0 :             sRetText = EditBrowseBox::GetAccessibleObjectDescription(_eObjType,_nPosition);
    2708             :     }
    2709           0 :     return sRetText;
    2710             : }
    2711             : // -----------------------------------------------------------------------------
    2712           0 : sal_Bool OSelectionBrowseBox::fillEntryTable(OTableFieldDescRef& _pEntry,const ::rtl::OUString& _sTableName)
    2713             : {
    2714           0 :     sal_Bool bRet = sal_False;
    2715           0 :     OJoinTableView::OTableWindowMap* pTabWinList = getDesignView()->getTableView()->GetTabWinMap();
    2716           0 :     if (pTabWinList)
    2717             :     {
    2718           0 :         OJoinTableView::OTableWindowMapIterator aIter = pTabWinList->find(_sTableName);
    2719           0 :         if(aIter != pTabWinList->end())
    2720             :         {
    2721           0 :             OQueryTableWindow* pEntryTab = static_cast<OQueryTableWindow*>(aIter->second);
    2722           0 :             if (pEntryTab)
    2723             :             {
    2724           0 :                 _pEntry->SetTable(pEntryTab->GetTableName());
    2725           0 :                 _pEntry->SetTabWindow(pEntryTab);
    2726           0 :                 bRet = sal_True;
    2727             :             }
    2728             :         }
    2729             :     }
    2730           0 :     return bRet;
    2731             : }
    2732             : // -----------------------------------------------------------------------------
    2733           0 : void OSelectionBrowseBox::setFunctionCell(OTableFieldDescRef& _pEntry)
    2734             : {
    2735           0 :     Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection();
    2736           0 :     if ( xConnection.is() )
    2737             :     {
    2738             :         // Aggregate functions in general only available with Core SQL
    2739           0 :         if ( lcl_SupportsCoreSQLGrammar(xConnection) )
    2740             :         {
    2741             :             // if we have an asterix, no other function than count is allowed
    2742           0 :             m_pFunctionCell->Clear();
    2743           0 :             m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(0));
    2744           0 :             if ( isFieldNameAsterix(_pEntry->GetField()) )
    2745           0 :                 m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(2)); // 2 -> COUNT
    2746             :             else
    2747             :             {
    2748           0 :                 xub_StrLen nCount = comphelper::string::getTokenCount(m_aFunctionStrings, ';');
    2749           0 :                 if ( _pEntry->isNumeric() )
    2750           0 :                     --nCount;
    2751           0 :                 for (xub_StrLen nIdx = 1; nIdx < nCount; nIdx++)
    2752           0 :                     m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(nIdx));
    2753             :             }
    2754             : 
    2755           0 :             if ( _pEntry->IsGroupBy() )
    2756             :             {
    2757             :                 OSL_ENSURE(!_pEntry->isNumeric(),"Not allowed to combine group by and numeric values!");
    2758           0 :                 m_pFunctionCell->SelectEntry(m_pFunctionCell->GetEntry(m_pFunctionCell->GetEntryCount() - 1));
    2759             :             }
    2760           0 :             else if ( m_pFunctionCell->GetEntryPos(String(_pEntry->GetFunction())) != COMBOBOX_ENTRY_NOTFOUND )
    2761           0 :                 m_pFunctionCell->SelectEntry(String(_pEntry->GetFunction()));
    2762             :             else
    2763           0 :                 m_pFunctionCell->SelectEntryPos(0);
    2764             : 
    2765           0 :             enableControl(_pEntry,m_pFunctionCell);
    2766             :         }
    2767             :         else
    2768             :         {
    2769             :             // only COUNT(*) and COUNT("table".*) allowed
    2770           0 :             sal_Bool bCountRemoved = !isFieldNameAsterix(_pEntry->GetField());
    2771           0 :             if ( bCountRemoved )
    2772           0 :                 m_pFunctionCell->RemoveEntry(1);
    2773             : 
    2774           0 :             if ( !bCountRemoved && m_pFunctionCell->GetEntryCount() < 2)
    2775           0 :                 m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(2)); // 2 -> COUNT
    2776             : 
    2777           0 :             if(m_pFunctionCell->GetEntryPos(String(_pEntry->GetFunction())) != COMBOBOX_ENTRY_NOTFOUND)
    2778           0 :                 m_pFunctionCell->SelectEntry(_pEntry->GetFunction());
    2779             :             else
    2780           0 :                 m_pFunctionCell->SelectEntryPos(0);
    2781             :         }
    2782           0 :     }
    2783           0 : }
    2784             : // -----------------------------------------------------------------------------
    2785           0 : Reference< XAccessible > OSelectionBrowseBox::CreateAccessibleCell( sal_Int32 _nRow, sal_uInt16 _nColumnPos )
    2786             : {
    2787           0 :     OTableFieldDescRef pEntry = NULL;
    2788           0 :     if(getFields().size() > sal_uInt16(_nColumnPos - 1))
    2789           0 :         pEntry = getFields()[_nColumnPos - 1];
    2790             : 
    2791           0 :     if ( _nRow == BROW_VIS_ROW && pEntry.is() )
    2792           0 :         return EditBrowseBox::CreateAccessibleCheckBoxCell( _nRow, _nColumnPos,pEntry->IsVisible() ? STATE_CHECK : STATE_NOCHECK );
    2793             : 
    2794           0 :     return EditBrowseBox::CreateAccessibleCell( _nRow, _nColumnPos );
    2795             : }
    2796             : // -----------------------------------------------------------------------------
    2797           0 : bool OSelectionBrowseBox::HasFieldByAliasName(const ::rtl::OUString& rFieldName, OTableFieldDescRef& rInfo) const
    2798             : {
    2799           0 :     OTableFields& aFields = getFields();
    2800           0 :     OTableFields::iterator aIter = aFields.begin();
    2801           0 :     OTableFields::iterator aEnd  = aFields.end();
    2802             : 
    2803           0 :     for(;aIter != aEnd;++aIter)
    2804             :     {
    2805           0 :         if ( (*aIter)->GetFieldAlias() == rFieldName )
    2806             :         {
    2807           0 :             *rInfo = *(*aIter);
    2808           0 :             break;
    2809             :         }
    2810             :     }
    2811           0 :     return aIter != aEnd;
    2812             : }
    2813             : // -----------------------------------------------------------------------------
    2814             : 
    2815             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10