| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_dbaccess.hxx" |
| #ifndef DBAUI_QUERYDESIGN_OSELECTIONBROWSEBOX_HXX |
| #include "SelectionBrowseBox.hxx" |
| #endif |
| #ifndef _COM_SUN_STAR_SDBC_XDATABASEMETADATA_HPP_ |
| #include <com/sun/star/sdbc/XDatabaseMetaData.hpp> |
| #endif |
| #ifndef _COM_SUN_STAR_SDBC_DATATYPE_HPP_ |
| #include <com/sun/star/sdbc/DataType.hpp> |
| #endif |
| #ifndef DBAUI_QUERYDESIGNVIEW_HXX |
| #include "QueryDesignView.hxx" |
| #endif |
| #ifndef DBAUI_QUERYCONTROLLER_HXX |
| #include "querycontroller.hxx" |
| #endif |
| #ifndef DBAUI_QUERYTABLEVIEW_HXX |
| #include "QueryTableView.hxx" |
| #endif |
| #ifndef DBACCESS_UI_BROWSER_ID_HXX |
| #include "browserids.hxx" |
| #endif |
| #ifndef _COMPHELPER_TYPES_HXX_ |
| #include <comphelper/types.hxx> |
| #endif |
| #ifndef DBAUI_TABLEFIELDINFO_HXX |
| #include "TableFieldInfo.hxx" |
| #endif |
| #ifndef _DBU_QRY_HRC_ |
| #include "dbu_qry.hrc" |
| #endif |
| #ifndef _DBA_DBACCESS_HELPID_HRC_ |
| #include "dbaccess_helpid.hrc" |
| #endif |
| #ifndef _TOOLS_DEBUG_HXX |
| #include <tools/debug.hxx> |
| #endif |
| #ifndef _COM_SUN_STAR_CONTAINER_XNAMEACCESS_HPP_ |
| #include <com/sun/star/container/XNameAccess.hpp> |
| #endif |
| #ifndef DBACCESS_SHARED_DBUSTRINGS_HRC |
| #include "dbustrings.hrc" |
| #endif |
| #ifndef DBAUI_QUERY_TABLEWINDOW_HXX |
| #include "QTableWindow.hxx" |
| #endif |
| #ifndef DBAUI_QUERYTABLEVIEW_HXX |
| #include "QueryTableView.hxx" |
| #endif |
| #ifndef _SV_MSGBOX_HXX |
| #include <vcl/msgbox.hxx> |
| #endif |
| #ifndef DBAUI_QUERYDESIGNFIELDUNDOACT_HXX |
| #include "QueryDesignFieldUndoAct.hxx" |
| #endif |
| #ifndef _SVX_DBEXCH_HRC |
| #include <svx/dbexch.hrc> |
| #endif |
| #ifndef _COMPHELPER_STLTYPES_HXX_ |
| #include <comphelper/stl_types.hxx> |
| #endif |
| #ifndef _COMPHELPER_EXTRACT_HXX_ |
| #include <comphelper/extract.hxx> |
| #endif |
| #ifndef _DBAUI_SQLMESSAGE_HXX_ |
| #include "sqlmessage.hxx" |
| #endif |
| #ifndef DBAUI_TOOLS_HXX |
| #include "UITools.hxx" |
| #endif |
| |
| using namespace ::svt; |
| using namespace ::dbaui; |
| using namespace ::connectivity; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::sdbc; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::container; |
| using namespace ::com::sun::star::util; |
| using namespace ::com::sun::star::accessibility; |
| |
| const String g_strOne = String::CreateFromAscii("1"); |
| const String g_strZero = String::CreateFromAscii("0"); |
| |
| #define DEFAULT_QUERY_COLS 20 |
| #define DEFAULT_SIZE GetTextWidth(g_strZero) * 30 |
| #define CHECKBOX_SIZE 10 |
| #define HANDLE_ID 0 |
| #define HANDLE_COLUMN_WITDH 70 |
| |
| #define SQL_ISRULEOR2(pParseNode, e1,e2) ((pParseNode)->isRule() && (\ |
| (pParseNode)->getRuleID() == OSQLParser::RuleID(OSQLParseNode::e1) || \ |
| (pParseNode)->getRuleID() == OSQLParser::RuleID(OSQLParseNode::e2))) |
| |
| |
| // ----------------------------------------------------------------------------- |
| namespace |
| { |
| sal_Bool isFieldNameAsterix(const ::rtl::OUString& _sFieldName ) |
| { |
| sal_Bool bAsterix = !(_sFieldName.getLength() && _sFieldName.toChar() != '*'); |
| if ( !bAsterix ) |
| { |
| String sName = _sFieldName; |
| xub_StrLen nTokenCount = sName.GetTokenCount('.'); |
| if ( (nTokenCount == 2 && sName.GetToken(1,'.').GetChar(0) == '*' ) |
| || (nTokenCount == 3 && sName.GetToken(2,'.').GetChar(0) == '*' ) ) |
| { |
| bAsterix = sal_True; |
| } |
| } |
| return bAsterix; |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool lcl_SupportsCoreSQLGrammar(const Reference< XConnection>& _xConnection) |
| { |
| sal_Bool bSupportsCoreGrammar = sal_False; |
| if ( _xConnection.is() ) |
| { |
| try |
| { |
| Reference< XDatabaseMetaData > xMetaData = _xConnection->getMetaData(); |
| bSupportsCoreGrammar = xMetaData.is() && xMetaData->supportsCoreSQLGrammar(); |
| } |
| catch(Exception&) |
| { |
| } |
| } |
| return bSupportsCoreGrammar; |
| } |
| } |
| |
| DBG_NAME(OSelectionBrowseBox) |
| //------------------------------------------------------------------------------ |
| OSelectionBrowseBox::OSelectionBrowseBox( Window* pParent ) |
| :EditBrowseBox( pParent,EBBF_NOROWPICTURE, WB_3DLOOK, BROWSER_COLUMNSELECTION | BROWSER_KEEPSELECTION | BROWSER_HIDESELECT | |
| BROWSER_HIDECURSOR | BROWSER_HLINESFULL | BROWSER_VLINESFULL ) |
| ,m_aFunctionStrings(ModuleRes(STR_QUERY_FUNCTIONS)) |
| ,m_nVisibleCount(0) |
| ,m_bOrderByUnRelated(sal_True) |
| ,m_bGroupByUnRelated(sal_True) |
| ,m_bStopTimer(sal_False) |
| ,m_bWasEditing(sal_False) |
| ,m_bDisableErrorBox(sal_False) |
| ,m_bInUndoMode(sal_False) |
| { |
| DBG_CTOR(OSelectionBrowseBox,NULL); |
| SetHelpId(HID_CTL_QRYDGNCRIT); |
| |
| m_nMode = BROWSER_COLUMNSELECTION | BROWSER_HIDESELECT |
| | BROWSER_KEEPSELECTION | BROWSER_HIDECURSOR |
| | BROWSER_HLINESFULL | BROWSER_VLINESFULL |
| | BROWSER_HEADERBAR_NEW ; |
| |
| m_pTextCell = new Edit(&GetDataWindow(), 0); |
| // m_pTextCell->EnableSpecialCheck(sal_False); |
| m_pVisibleCell = new CheckBoxControl(&GetDataWindow()); |
| m_pTableCell = new ListBoxControl(&GetDataWindow()); m_pTableCell->SetDropDownLineCount( 20 ); |
| m_pFieldCell = new ComboBoxControl(&GetDataWindow()); m_pFieldCell->SetDropDownLineCount( 20 ); |
| m_pOrderCell = new ListBoxControl(&GetDataWindow()); |
| m_pFunctionCell = new ListBoxControl(&GetDataWindow()); m_pFunctionCell->SetDropDownLineCount( 20 ); |
| |
| m_pVisibleCell->SetHelpId(HID_QRYDGN_ROW_VISIBLE); |
| m_pTableCell->SetHelpId(HID_QRYDGN_ROW_TABLE); |
| m_pFieldCell->SetHelpId(HID_QRYDGN_ROW_FIELD); |
| m_pOrderCell->SetHelpId(HID_QRYDGN_ROW_ORDER); |
| m_pFunctionCell->SetHelpId(HID_QRYDGN_ROW_FUNCTION); |
| |
| ////////////////////////////////////////////////////////////////////// |
| // TriState der ::com::sun::star::form::CheckBox abschalten |
| m_pVisibleCell->GetBox().EnableTriState( sal_False ); |
| |
| // m_pEmptyEntry = new OTableFieldDesc(); |
| // m_pEmptyEntry->SetColWidth(DEFAULT_SIZE); |
| |
| Font aTitleFont = OutputDevice::GetDefaultFont( DEFAULTFONT_SANS_UNICODE,Window::GetSettings().GetLanguage(),DEFAULTFONT_FLAGS_ONLYONE); |
| aTitleFont.SetSize(Size(0, 6)); |
| SetTitleFont(aTitleFont); |
| |
| String aTxt(ModuleRes(STR_QUERY_SORTTEXT)); |
| xub_StrLen nCount = aTxt.GetTokenCount(); |
| xub_StrLen nIdx = 0; |
| for (; nIdx < nCount; nIdx++) |
| m_pOrderCell->InsertEntry(aTxt.GetToken(nIdx)); |
| |
| for(long i=0;i < BROW_ROW_CNT;i++) |
| m_bVisibleRow.push_back(sal_True); |
| |
| m_bVisibleRow[BROW_FUNCTION_ROW] = sal_False; // zuerst ausblenden |
| |
| m_timerInvalidate.SetTimeout(200); |
| m_timerInvalidate.SetTimeoutHdl(LINK(this, OSelectionBrowseBox, OnInvalidateTimer)); |
| m_timerInvalidate.Start(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| OSelectionBrowseBox::~OSelectionBrowseBox() |
| { |
| DBG_DTOR(OSelectionBrowseBox,NULL); |
| |
| delete m_pTextCell; |
| delete m_pVisibleCell; |
| delete m_pFieldCell; |
| delete m_pTableCell; |
| delete m_pOrderCell; |
| delete m_pFunctionCell; |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::initialize() |
| { |
| Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection(); |
| if(xConnection.is()) |
| { |
| const IParseContext& rContext = static_cast<OQueryController&>(getDesignView()->getController()).getParser().getContext(); |
| IParseContext::InternationalKeyCode eFunctions[] = { IParseContext::KEY_AVG,IParseContext::KEY_COUNT,IParseContext::KEY_MAX |
| ,IParseContext::KEY_MIN,IParseContext::KEY_SUM |
| ,IParseContext::KEY_EVERY |
| ,IParseContext::KEY_ANY |
| ,IParseContext::KEY_SOME |
| ,IParseContext::KEY_STDDEV_POP |
| ,IParseContext::KEY_STDDEV_SAMP |
| ,IParseContext::KEY_VAR_SAMP |
| ,IParseContext::KEY_VAR_POP |
| ,IParseContext::KEY_COLLECT |
| ,IParseContext::KEY_FUSION |
| ,IParseContext::KEY_INTERSECTION |
| }; |
| |
| String sGroup = m_aFunctionStrings.GetToken(m_aFunctionStrings.GetTokenCount() - 1); |
| m_aFunctionStrings = m_aFunctionStrings.GetToken(0); |
| |
| for (size_t i = 0; i < sizeof(eFunctions)/sizeof(eFunctions[0]) ; ++i) |
| { |
| m_aFunctionStrings += String(RTL_CONSTASCII_USTRINGPARAM(";")); |
| m_aFunctionStrings += String(ByteString(rContext.getIntlKeywordAscii(eFunctions[i])),RTL_TEXTENCODING_UTF8); |
| |
| } // for (sal_Int32 i = 0; i < sizeof(eFunctions)/sizeof(eFunctions[0]) ; ++i) |
| m_aFunctionStrings += String(RTL_CONSTASCII_USTRINGPARAM(";")); |
| m_aFunctionStrings += sGroup; |
| |
| // Diese Funktionen stehen nur unter CORE zur Verfügung |
| if ( lcl_SupportsCoreSQLGrammar(xConnection) ) |
| { |
| xub_StrLen nCount = m_aFunctionStrings.GetTokenCount(); |
| for (xub_StrLen nIdx = 0; nIdx < nCount; nIdx++) |
| m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(nIdx)); |
| } |
| else // sonst nur COUNT(*) |
| { |
| m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(0)); |
| m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(2)); // 2 -> COUNT |
| } |
| try |
| { |
| Reference< XDatabaseMetaData > xMetaData = xConnection->getMetaData(); |
| if ( xMetaData.is() ) |
| { |
| m_bOrderByUnRelated = xMetaData->supportsOrderByUnrelated(); |
| m_bGroupByUnRelated = xMetaData->supportsGroupByUnrelated(); |
| } |
| } |
| catch(Exception&) |
| { |
| } |
| } |
| |
| Init(); |
| } |
| //============================================================================== |
| OQueryDesignView* OSelectionBrowseBox::getDesignView() |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| OSL_ENSURE(static_cast<const OQueryDesignView*>(GetParent()),"Parent isn't an OQueryDesignView!"); |
| return static_cast<OQueryDesignView*>(GetParent()); |
| } |
| // ----------------------------------------------------------------------------- |
| OQueryDesignView* OSelectionBrowseBox::getDesignView() const |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| OSL_ENSURE(static_cast<const OQueryDesignView*>(GetParent()),"Parent isn't an OQueryDesignView!"); |
| return static_cast<OQueryDesignView*>(GetParent()); |
| } |
| namespace |
| { |
| class OSelectionBrwBoxHeader : public ::svt::EditBrowserHeader |
| { |
| OSelectionBrowseBox* m_pBrowseBox; |
| protected: |
| virtual void Select(); |
| public: |
| OSelectionBrwBoxHeader(OSelectionBrowseBox* pParent); |
| }; |
| OSelectionBrwBoxHeader::OSelectionBrwBoxHeader(OSelectionBrowseBox* pParent) |
| : ::svt::EditBrowserHeader(pParent,WB_BUTTONSTYLE|WB_DRAG) |
| ,m_pBrowseBox(pParent) |
| { |
| } |
| |
| void OSelectionBrwBoxHeader::Select() |
| { |
| EditBrowserHeader::Select(); |
| m_pBrowseBox->GrabFocus(); |
| |
| BrowserMode nMode = m_pBrowseBox->GetMode(); |
| if ( 0 == m_pBrowseBox->GetSelectColumnCount() ) |
| { |
| m_pBrowseBox->DeactivateCell(); |
| // wenn es schon eine selektierte Spalte gibt, bin ich schon im richtigen Modus |
| if ( BROWSER_HIDESELECT == ( nMode & BROWSER_HIDESELECT ) ) |
| { |
| nMode &= ~BROWSER_HIDESELECT; |
| nMode |= BROWSER_MULTISELECTION; |
| m_pBrowseBox->SetMode( nMode ); |
| } |
| } |
| m_pBrowseBox->SelectColumnId( GetCurItemId() ); |
| m_pBrowseBox->DeactivateCell(); |
| } |
| } |
| |
| // ----------------------------------------------------------------------------- |
| BrowserHeader* OSelectionBrowseBox::imp_CreateHeaderBar(BrowseBox* /*pParent*/) |
| { |
| return new OSelectionBrwBoxHeader(this); |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::ColumnMoved( sal_uInt16 nColId,sal_Bool _bCreateUndo ) |
| { |
| EditBrowseBox::ColumnMoved( nColId ); |
| // swap the two columns |
| sal_uInt16 nNewPos = GetColumnPos( nColId ); |
| OTableFields& rFields = getFields(); |
| if ( rFields.size() > sal_uInt16(nNewPos-1) ) |
| { |
| sal_uInt16 nOldPos = 0; |
| OTableFields::iterator aEnd = rFields.end(); |
| OTableFields::iterator aIter = rFields.begin(); |
| for (; aIter != aEnd && ( (*aIter)->GetColumnId() != nColId ); ++aIter,++nOldPos) |
| ; |
| |
| OSL_ENSURE( (nNewPos-1) != nOldPos && nOldPos < rFields.size(),"Old and new position are equal!"); |
| if ( aIter != aEnd ) |
| { |
| OTableFieldDescRef pOldEntry = rFields[nOldPos]; |
| rFields.erase(rFields.begin() + nOldPos); |
| rFields.insert(rFields.begin() + nNewPos - 1,pOldEntry); |
| |
| // create the undo action |
| if ( !m_bInUndoMode && _bCreateUndo ) |
| { |
| OTabFieldMovedUndoAct* pUndoAct = new OTabFieldMovedUndoAct(this); |
| pUndoAct->SetColumnPosition( nOldPos + 1); |
| pUndoAct->SetTabFieldDescr(pOldEntry); |
| |
| getDesignView()->getController().addUndoActionAndInvalidate(pUndoAct); |
| } // if ( !m_bInUndoMode && _bCreateUndo ) |
| } |
| } |
| else |
| OSL_ENSURE(0,"Invalid column id!"); |
| } |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::Init() |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| |
| EditBrowseBox::Init(); |
| |
| // set the header bar |
| BrowserHeader* pNewHeaderBar = CreateHeaderBar(this); |
| pNewHeaderBar->SetMouseTransparent(sal_False); |
| |
| SetHeaderBar(pNewHeaderBar); |
| SetMode(m_nMode); |
| |
| Font aFont( GetDataWindow().GetFont() ); |
| aFont.SetWeight( WEIGHT_NORMAL ); |
| GetDataWindow().SetFont( aFont ); |
| |
| Size aHeight; |
| const Control* pControls[] = { m_pTextCell,m_pVisibleCell,m_pTableCell,m_pFieldCell }; |
| for(sal_Size i= 0; i < sizeof(pControls)/sizeof(pControls[0]);++i) |
| { |
| const Size aTemp( pControls[i]->GetOptimalSize(WINDOWSIZE_PREFERRED) ); |
| if ( aTemp.Height() > aHeight.Height() ) |
| aHeight.Height() = aTemp.Height(); |
| } // for(int i= 0; i < sizeof(pControls)/sizeof(pControls[0]);++i |
| SetDataRowHeight(aHeight.Height()); |
| SetTitleLines(1); |
| // Anzahl der sichtbaren Zeilen ermitteln |
| for(long i=0;i<BROW_ROW_CNT;i++) |
| { |
| if(m_bVisibleRow[i]) |
| m_nVisibleCount++; |
| } |
| RowInserted(0, m_nVisibleCount, sal_False); |
| try |
| { |
| Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection(); |
| if(xConnection.is()) |
| { |
| Reference< XDatabaseMetaData > xMetaData = xConnection->getMetaData(); |
| m_nMaxColumns = xMetaData.is() ? xMetaData->getMaxColumnsInSelect() : 0; |
| |
| } |
| else |
| m_nMaxColumns = 0; |
| } |
| catch(const SQLException&) |
| { |
| OSL_ENSURE(0,"Catched Exception when asking for database metadata options!"); |
| m_nMaxColumns = 0; |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::PreFill() |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| SetUpdateMode(sal_False); |
| |
| if (GetCurRow() != 0) |
| GoToRow(0); |
| |
| |
| static_cast< OQueryController& >( getDesignView()->getController() ).clearFields(); |
| |
| DeactivateCell(); |
| |
| RemoveColumns(); |
| InsertHandleColumn( HANDLE_COLUMN_WITDH ); |
| SetUpdateMode(sal_True); |
| } |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::ClearAll() |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| SetUpdateMode(sal_False); |
| |
| OTableFields::reverse_iterator aIter = getFields().rbegin(); |
| for ( ;aIter != getFields().rend(); ++aIter ) |
| { |
| if ( !(*aIter)->IsEmpty() ) |
| { |
| RemoveField( (*aIter)->GetColumnId() ); |
| aIter = getFields().rbegin(); |
| } |
| } |
| SetUpdateMode(sal_True); |
| } |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::SetReadOnly(sal_Bool bRO) |
| { |
| if (bRO) |
| { |
| DeactivateCell(); |
| m_nMode &= ~BROWSER_HIDECURSOR; |
| SetMode(m_nMode); |
| } |
| else |
| { |
| m_nMode |= BROWSER_HIDECURSOR; |
| SetMode(m_nMode); |
| ActivateCell(); |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| CellController* OSelectionBrowseBox::GetController(long nRow, sal_uInt16 nColId) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| if ( nColId > getFields().size() ) |
| return NULL; |
| OTableFieldDescRef pEntry = getFields()[nColId-1]; |
| DBG_ASSERT(pEntry.isValid(), "OSelectionBrowseBox::GetController : keine FieldDescription !"); |
| |
| if (!pEntry.isValid()) |
| return NULL; |
| |
| if (static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly()) |
| return NULL; |
| |
| long nCellIndex = GetRealRow(nRow); |
| switch (nCellIndex) |
| { |
| case BROW_FIELD_ROW: |
| return new ComboBoxCellController(m_pFieldCell); |
| case BROW_TABLE_ROW: |
| return new ListBoxCellController(m_pTableCell); |
| case BROW_VIS_ROW: |
| return new CheckBoxCellController(m_pVisibleCell); |
| case BROW_ORDER_ROW: |
| return new ListBoxCellController(m_pOrderCell); |
| case BROW_FUNCTION_ROW: |
| return new ListBoxCellController(m_pFunctionCell); |
| default: |
| return new EditCellController(m_pTextCell); |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::InitController(CellControllerRef& /*rController*/, long nRow, sal_uInt16 nColId) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| OSL_ENSURE(nColId != BROWSER_INVALIDID,"An Invalid Id was set!"); |
| if ( nColId == BROWSER_INVALIDID ) |
| return; |
| sal_uInt16 nPos = GetColumnPos(nColId); |
| if ( nPos == 0 || nPos == BROWSER_INVALIDID || nPos > getFields().size() ) |
| return; |
| OTableFieldDescRef pEntry = getFields()[nPos-1]; |
| DBG_ASSERT(pEntry.isValid(), "OSelectionBrowseBox::InitController : keine FieldDescription !"); |
| long nCellIndex = GetRealRow(nRow); |
| |
| switch (nCellIndex) |
| { |
| case BROW_FIELD_ROW: |
| { |
| m_pFieldCell->Clear(); |
| m_pFieldCell->SetText(String()); |
| |
| String aField(pEntry->GetField()); |
| String aTable(pEntry->GetAlias()); |
| |
| getDesignView()->fillValidFields(aTable, m_pFieldCell); |
| |
| // * durch alias.* ersetzen |
| if ((aField.GetChar(0) == '*') && aTable.Len()) |
| { |
| aField = aTable; |
| aField.AppendAscii(".*"); |
| } |
| m_pFieldCell->SetText(aField); |
| } break; |
| case BROW_TABLE_ROW: |
| { |
| m_pTableCell->Clear(); |
| enableControl(pEntry,m_pTableCell); |
| if ( !pEntry->isCondition() ) |
| { |
| OJoinTableView::OTableWindowMap* pTabWinList = getDesignView()->getTableView()->GetTabWinMap(); |
| if (pTabWinList) |
| { |
| OJoinTableView::OTableWindowMap::iterator aIter = pTabWinList->begin(); |
| OJoinTableView::OTableWindowMap::iterator aEnd = pTabWinList->end(); |
| |
| for(;aIter != aEnd;++aIter) |
| m_pTableCell->InsertEntry(static_cast<OQueryTableWindow*>(aIter->second)->GetAliasName()); |
| |
| m_pTableCell->InsertEntry(String(ModuleRes(STR_QUERY_NOTABLE)), 0); |
| if (pEntry->GetAlias().getLength()) |
| m_pTableCell->SelectEntry(pEntry->GetAlias()); |
| else |
| m_pTableCell->SelectEntry(String(ModuleRes(STR_QUERY_NOTABLE))); |
| } |
| } |
| } break; |
| case BROW_VIS_ROW: |
| { |
| m_pVisibleCell->GetBox().Check(pEntry->IsVisible()); |
| m_pVisibleCell->GetBox().SaveValue(); |
| |
| enableControl(pEntry,m_pTextCell); |
| |
| if(!pEntry->IsVisible() && pEntry->GetOrderDir() != ORDER_NONE && !m_bOrderByUnRelated) |
| { |
| // Spalte muss sichtbar sein, um im ORDER BY aufzutauchen |
| pEntry->SetVisible(sal_True); |
| m_pVisibleCell->GetBox().Check(pEntry->IsVisible()); |
| m_pVisibleCell->GetBox().SaveValue(); |
| m_pVisibleCell->GetBox().Disable(); |
| m_pVisibleCell->GetBox().EnableInput(sal_False); |
| String aMessage(ModuleRes(STR_QRY_ORDERBY_UNRELATED)); |
| OQueryDesignView* paDView = getDesignView(); |
| InfoBox(paDView, aMessage).Execute(); |
| } |
| } break; |
| case BROW_ORDER_ROW: |
| m_pOrderCell->SelectEntryPos( |
| sal::static_int_cast< sal_uInt16 >(pEntry->GetOrderDir())); |
| enableControl(pEntry,m_pOrderCell); |
| break; |
| case BROW_COLUMNALIAS_ROW: |
| setTextCellContext(pEntry,pEntry->GetFieldAlias(),HID_QRYDGN_ROW_ALIAS); |
| break; |
| case BROW_FUNCTION_ROW: |
| setFunctionCell(pEntry); |
| break; |
| default: |
| { |
| sal_uInt16 nIdx = sal_uInt16(nCellIndex - BROW_CRIT1_ROW); |
| setTextCellContext(pEntry,pEntry->GetCriteria( nIdx ),HID_QRYDGN_ROW_CRIT); |
| } |
| } |
| Controller()->ClearModified(); |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::notifyTableFieldChanged(const String& _sOldAlias,const String& _sAlias,sal_Bool& _bListAction,sal_uInt16 _nColumnId) |
| { |
| appendUndoAction(_sOldAlias,_sAlias,BROW_TABLE_ROW,_bListAction); |
| if ( m_bVisibleRow[BROW_TABLE_ROW] ) |
| RowModified(GetBrowseRow(BROW_TABLE_ROW), _nColumnId); |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::notifyFunctionFieldChanged(const String& _sOldFunctionName,const String& _sFunctionName,sal_Bool& _bListAction,sal_uInt16 _nColumnId) |
| { |
| appendUndoAction(_sOldFunctionName,_sFunctionName,BROW_FUNCTION_ROW,_bListAction); |
| if ( !m_bVisibleRow[BROW_FUNCTION_ROW] ) |
| SetRowVisible(BROW_FUNCTION_ROW, sal_True); |
| RowModified(GetBrowseRow(BROW_FUNCTION_ROW), _nColumnId); |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::clearEntryFunctionField(const String& _sFieldName,OTableFieldDescRef& _pEntry,sal_Bool& _bListAction,sal_uInt16 _nColumnId) |
| { |
| if ( isFieldNameAsterix( _sFieldName ) && (!_pEntry->isNoneFunction() || _pEntry->IsGroupBy()) ) |
| { |
| String sFunctionName; |
| GetFunctionName(SQL_TOKEN_COUNT,sFunctionName); |
| String sOldLocalizedFunctionName = _pEntry->GetFunction(); |
| if ( !sOldLocalizedFunctionName.Equals(sFunctionName) || _pEntry->IsGroupBy() ) |
| { |
| // append undo action for the function field |
| _pEntry->SetFunctionType(FKT_NONE); |
| _pEntry->SetFunction(::rtl::OUString()); |
| _pEntry->SetGroupBy(sal_False); |
| notifyFunctionFieldChanged(sOldLocalizedFunctionName,_pEntry->GetFunction(),_bListAction,_nColumnId); |
| } |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool OSelectionBrowseBox::fillColumnRef(const OSQLParseNode* _pColumnRef, const Reference< XConnection >& _rxConnection, OTableFieldDescRef& _pEntry, sal_Bool& _bListAction ) |
| { |
| OSL_ENSURE(_pColumnRef,"No valid parsenode!"); |
| ::rtl::OUString sColumnName,sTableRange; |
| OSQLParseTreeIterator::getColumnRange(_pColumnRef,_rxConnection,sColumnName,sTableRange); |
| return fillColumnRef(sColumnName,sTableRange,_rxConnection->getMetaData(),_pEntry,_bListAction); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool OSelectionBrowseBox::fillColumnRef(const ::rtl::OUString& _sColumnName,const ::rtl::OUString& _sTableRange,const Reference<XDatabaseMetaData>& _xMetaData,OTableFieldDescRef& _pEntry,sal_Bool& _bListAction) |
| { |
| sal_Bool bError = sal_False; |
| ::comphelper::UStringMixEqual bCase(_xMetaData->supportsMixedCaseQuotedIdentifiers()); |
| // check if the table name is the same |
| if ( _sTableRange.getLength() && (bCase(_pEntry->GetTable(),_sTableRange) || bCase(_pEntry->GetAlias(),_sTableRange)) ) |
| { // a table was already inserted and the tables contains that column name |
| |
| if ( !_pEntry->GetTabWindow() ) |
| { // fill tab window |
| ::rtl::OUString sOldAlias = _pEntry->GetAlias(); |
| if ( !fillEntryTable(_pEntry,_pEntry->GetTable()) ) |
| fillEntryTable(_pEntry,_pEntry->GetAlias()); // only when the first failed |
| if ( !bCase(sOldAlias,_pEntry->GetAlias()) ) |
| notifyTableFieldChanged(sOldAlias,_pEntry->GetAlias(),_bListAction,GetCurColumnId()); |
| } |
| } |
| // check if the table window |
| OQueryTableWindow* pEntryTab = static_cast<OQueryTableWindow*>(_pEntry->GetTabWindow()); |
| if ( !pEntryTab ) // no table found with this name so we have to travel through all tables |
| { |
| OJoinTableView::OTableWindowMap* pTabWinList = getDesignView()->getTableView()->GetTabWinMap(); |
| if ( pTabWinList ) |
| { |
| sal_uInt16 nTabCount = 0; |
| if ( !static_cast<OQueryTableView*>(getDesignView()->getTableView())->FindTableFromField(_sColumnName,_pEntry,nTabCount) ) // error occured: column not in table window |
| { |
| String sErrorMsg(ModuleRes(RID_STR_FIELD_DOESNT_EXIST)); |
| sErrorMsg.SearchAndReplaceAscii("$name$",_sColumnName); |
| OSQLWarningBox( this, sErrorMsg ).Execute(); |
| bError = sal_True; |
| } |
| else |
| { |
| pEntryTab = static_cast<OQueryTableWindow*>(_pEntry->GetTabWindow()); |
| notifyTableFieldChanged(String(),_pEntry->GetAlias(),_bListAction,GetCurColumnId()); |
| } |
| } |
| } |
| if ( pEntryTab ) // here we got a valid table |
| _pEntry->SetField(_sColumnName); |
| |
| return bError; |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool OSelectionBrowseBox::saveField(const String& _sFieldName,OTableFieldDescRef& _pEntry,sal_Bool& _bListAction) |
| { |
| sal_Bool bError = sal_False; |
| |
| OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController()); |
| |
| // first look if the name can be found in our tables |
| sal_uInt16 nTabCount = 0; |
| String sOldAlias = _pEntry->GetAlias(); |
| if ( static_cast<OQueryTableView*>(getDesignView()->getTableView())->FindTableFromField(_sFieldName,_pEntry,nTabCount) ) |
| { |
| // append undo action for the alias name |
| _pEntry->SetField(_sFieldName); |
| notifyTableFieldChanged(sOldAlias,_pEntry->GetAlias(),_bListAction,GetCurColumnId()); |
| clearEntryFunctionField(_sFieldName,_pEntry,_bListAction,_pEntry->GetColumnId()); |
| return bError; |
| } |
| |
| Reference<XConnection> xConnection( rController.getConnection() ); |
| Reference< XDatabaseMetaData > xMetaData; |
| if ( xConnection.is() ) |
| xMetaData = xConnection->getMetaData(); |
| OSL_ENSURE( xMetaData.is(), "OSelectionBrowseBox::saveField: invalid connection/meta data!" ); |
| if ( !xMetaData.is() ) |
| return sal_True; |
| |
| ::rtl::OUString sErrorMsg; |
| // second test if the name can be set as select columns in a pseudo statement |
| // we have to look which entries we should quote |
| |
| const ::rtl::OUString sFieldAlias = _pEntry->GetFieldAlias(); |
| size_t nPass = 4; |
| ::connectivity::OSQLParser& rParser( rController.getParser() ); |
| OSQLParseNode* pParseNode = NULL; |
| // 4 passes in trying to interprete the field name |
| // - don't quote the field name, parse internationally |
| // - don't quote the field name, parse en-US |
| // - quote the field name, parse internationally |
| // - quote the field name, parse en-US |
| do |
| { |
| bool bQuote = ( nPass <= 2 ); |
| bool bInternational = ( nPass % 2 ) == 0; |
| |
| ::rtl::OUString sSql; |
| if ( bQuote ) |
| sSql += ::dbtools::quoteName( xMetaData->getIdentifierQuoteString(), _sFieldName ); |
| else |
| sSql += _sFieldName; |
| |
| if ( _pEntry->isAggreateFunction() ) |
| { |
| DBG_ASSERT(_pEntry->GetFunction().getLength(),"Functionname darf hier nicht leer sein! ;-("); |
| ::rtl::OUStringBuffer aTmpStr2( _pEntry->GetFunction()); |
| aTmpStr2.appendAscii("("); |
| aTmpStr2.append(sSql); |
| aTmpStr2.appendAscii(")"); |
| sSql = aTmpStr2.makeStringAndClear(); |
| } |
| |
| sSql = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("SELECT ")) + sSql; |
| if ( sFieldAlias.getLength() ) |
| { // always quote the alias name there canbe no function in it |
| sSql += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" ")); |
| sSql += ::dbtools::quoteName( xMetaData->getIdentifierQuoteString(), sFieldAlias ); |
| } |
| sSql += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" FROM x")); |
| |
| pParseNode = rParser.parseTree( sErrorMsg, sSql, bInternational ); |
| } |
| while ( ( pParseNode == NULL ) && ( --nPass > 0 ) ); |
| |
| if ( pParseNode == NULL ) |
| { |
| // something different which we have to check (may be a select statement) |
| String sErrorMessage( ModuleRes( STR_QRY_COLUMN_NOT_FOUND ) ); |
| sErrorMessage.SearchAndReplaceAscii("$name$",_sFieldName); |
| OSQLWarningBox( this, sErrorMessage ).Execute(); |
| return sal_True; |
| } |
| |
| // we got a valid select column |
| // find what type of column has be inserted |
| ::connectivity::OSQLParseNode* pSelection = pParseNode->getChild(2); |
| if ( SQL_ISRULE(pSelection,selection) ) // we found the asterix |
| { |
| _pEntry->SetField(_sFieldName); |
| clearEntryFunctionField(_sFieldName,_pEntry,_bListAction,_pEntry->GetColumnId()); |
| } // travel through the select column parse node |
| else |
| { |
| ::comphelper::UStringMixEqual bCase(xMetaData->supportsMixedCaseQuotedIdentifiers()); |
| |
| OTableFieldDescRef aSelEntry = _pEntry; |
| sal_uInt16 nColumnId = aSelEntry->GetColumnId(); |
| |
| sal_uInt32 nCount = pSelection->count(); |
| for (sal_uInt32 i = 0; i < nCount; ++i) |
| { |
| if ( i > 0 ) // may we have to append more than one field |
| { |
| sal_uInt16 nColumnPostion; |
| aSelEntry = FindFirstFreeCol(nColumnPostion); |
| if ( !aSelEntry.isValid() ) |
| { |
| AppendNewCol(1); |
| aSelEntry = FindFirstFreeCol(nColumnPostion); |
| } |
| ++nColumnPostion; |
| nColumnId = GetColumnId(nColumnPostion); |
| } |
| |
| ::connectivity::OSQLParseNode* pChild = pSelection->getChild( i ); |
| OSL_ENSURE(SQL_ISRULE(pChild,derived_column), "No derived column found!"); |
| // get the column alias |
| ::rtl::OUString sColumnAlias = OSQLParseTreeIterator::getColumnAlias(pChild); |
| if ( sColumnAlias.getLength() ) // we found an as clause |
| { |
| String aSelectionAlias = aSelEntry->GetFieldAlias(); |
| aSelEntry->SetFieldAlias( sColumnAlias ); |
| // append undo |
| appendUndoAction(aSelectionAlias,aSelEntry->GetFieldAlias(),BROW_COLUMNALIAS_ROW,_bListAction); |
| if ( m_bVisibleRow[BROW_COLUMNALIAS_ROW] ) |
| RowModified(GetBrowseRow(BROW_COLUMNALIAS_ROW), nColumnId); |
| } |
| |
| ::connectivity::OSQLParseNode* pColumnRef = pChild->getChild(0); |
| if ( |
| pColumnRef->count() == 3 && |
| SQL_ISPUNCTUATION(pColumnRef->getChild(0),"(") && |
| SQL_ISPUNCTUATION(pColumnRef->getChild(2),")") |
| ) |
| pColumnRef = pColumnRef->getChild(1); |
| |
| if ( SQL_ISRULE(pColumnRef,column_ref) ) // we found a valid column name or more column names |
| { |
| // look if we can find the corresponding table |
| bError = fillColumnRef( pColumnRef, xConnection, aSelEntry, _bListAction ); |
| |
| // we found a simple column so we must clear the function fields but only when the column name is '*' |
| // and the function is different to count |
| clearEntryFunctionField(_sFieldName,aSelEntry,_bListAction,nColumnId); |
| } |
| else |
| { |
| // first check if we have a aggregate function and only a function |
| if ( SQL_ISRULE(pColumnRef,general_set_fct) ) |
| { |
| String sLocalizedFunctionName; |
| if ( GetFunctionName(pColumnRef->getChild(0)->getTokenID(),sLocalizedFunctionName) ) |
| { |
| String sOldLocalizedFunctionName = aSelEntry->GetFunction(); |
| aSelEntry->SetFunction(sLocalizedFunctionName); |
| sal_uInt32 nFunCount = pColumnRef->count() - 1; |
| sal_Int32 nFunctionType = FKT_AGGREGATE; |
| sal_Bool bQuote = sal_False; |
| // may be there exists only one parameter which is a column, fill all information into our fields |
| if ( nFunCount == 4 && SQL_ISRULE(pColumnRef->getChild(3),column_ref) ) |
| bError = fillColumnRef( pColumnRef->getChild(3), xConnection, aSelEntry, _bListAction ); |
| else if ( nFunCount == 3 ) // we have a COUNT(*) here, so take the first table |
| bError = fillColumnRef( ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("*")), ::rtl::OUString(), xMetaData, aSelEntry, _bListAction ); |
| else |
| { |
| nFunctionType |= FKT_NUMERIC; |
| bQuote = sal_True; |
| aSelEntry->SetDataType(DataType::DOUBLE); |
| aSelEntry->SetFieldType(TAB_NORMAL_FIELD); |
| } |
| |
| // now parse the parameters |
| ::rtl::OUString sParameters; |
| for(sal_uInt32 function = 2; function < nFunCount; ++function) // we only want to parse the parameters of the function |
| pColumnRef->getChild(function)->parseNodeToStr( sParameters, xConnection, &rParser.getContext(), sal_True, bQuote ); |
| |
| aSelEntry->SetFunctionType(nFunctionType); |
| aSelEntry->SetField(sParameters); |
| if ( aSelEntry->IsGroupBy() ) |
| { |
| sOldLocalizedFunctionName = m_aFunctionStrings.GetToken(m_aFunctionStrings.GetTokenCount()-1); |
| aSelEntry->SetGroupBy(sal_False); |
| } |
| |
| // append undo action |
| notifyFunctionFieldChanged(sOldLocalizedFunctionName,sLocalizedFunctionName,_bListAction, nColumnId); |
| } |
| else |
| OSL_ENSURE(0,"Unsupported function inserted!"); |
| |
| } |
| else |
| { |
| // so we first clear the function field |
| clearEntryFunctionField(_sFieldName,aSelEntry,_bListAction,nColumnId); |
| ::rtl::OUString sFunction; |
| pColumnRef->parseNodeToStr( sFunction, |
| xConnection, |
| &rController.getParser().getContext(), |
| sal_True, |
| sal_True); // quote is to true because we need quoted elements inside the function |
| |
| getDesignView()->fillFunctionInfo(pColumnRef,sFunction,aSelEntry); |
| |
| if( SQL_ISRULEOR2(pColumnRef,position_exp,extract_exp) || |
| SQL_ISRULEOR2(pColumnRef,fold,char_substring_fct) || |
| SQL_ISRULEOR2(pColumnRef,length_exp,char_value_fct) ) |
| // a calculation has been found ( can be calc and function ) |
| { |
| // now parse the whole statement |
| sal_uInt32 nFunCount = pColumnRef->count(); |
| ::rtl::OUString sParameters; |
| for(sal_uInt32 function = 0; function < nFunCount; ++function) |
| pColumnRef->getChild(function)->parseNodeToStr( sParameters, xConnection, &rParser.getContext(), sal_True, sal_True ); |
| |
| sOldAlias = aSelEntry->GetAlias(); |
| sal_Int32 nNewFunctionType = aSelEntry->GetFunctionType() | FKT_NUMERIC | FKT_OTHER; |
| aSelEntry->SetFunctionType(nNewFunctionType); |
| aSelEntry->SetField(sParameters); |
| } |
| else |
| { |
| aSelEntry->SetFieldAlias(sColumnAlias); |
| if ( SQL_ISRULE(pColumnRef,set_fct_spec) ) |
| aSelEntry->SetFunctionType(/*FKT_NUMERIC | */FKT_OTHER); |
| else |
| { |
| if ( SQL_ISRULEOR2(pColumnRef,num_value_exp,term) || SQL_ISRULE(pColumnRef,factor) ) |
| aSelEntry->SetDataType(DataType::DOUBLE); |
| else if ( SQL_ISRULE(pColumnRef,value_exp) ) |
| aSelEntry->SetDataType(DataType::TIMESTAMP); |
| else |
| aSelEntry->SetDataType(DataType::VARCHAR); |
| aSelEntry->SetFunctionType(FKT_NUMERIC | FKT_OTHER); |
| } |
| } |
| |
| aSelEntry->SetAlias(::rtl::OUString()); |
| notifyTableFieldChanged(sOldAlias,aSelEntry->GetAlias(),_bListAction, nColumnId); |
| } |
| |
| } |
| if ( i > 0 && InsertField(aSelEntry,BROWSER_INVALIDID,sal_True,sal_False).isEmpty() ) // may we have to append more than one field |
| { // the field could not be isnerted |
| String sErrorMessage( ModuleRes( RID_STR_FIELD_DOESNT_EXIST ) ); |
| sErrorMessage.SearchAndReplaceAscii("$name$",aSelEntry->GetField()); |
| OSQLWarningBox( this, sErrorMessage ).Execute(); |
| bError = sal_True; |
| } |
| } |
| } |
| delete pParseNode; |
| |
| return bError; |
| } |
| //------------------------------------------------------------------------------ |
| sal_Bool OSelectionBrowseBox::SaveModified() |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController()); |
| OTableFieldDescRef pEntry = NULL; |
| sal_uInt16 nCurrentColumnPos = GetColumnPos(GetCurColumnId()); |
| if(getFields().size() > static_cast<sal_uInt16>(nCurrentColumnPos - 1)) |
| pEntry = getEntry(nCurrentColumnPos - 1); |
| |
| sal_Bool bWasEmpty = pEntry.isValid() ? pEntry->IsEmpty() : sal_False; |
| sal_Bool bError = sal_False; |
| sal_Bool bListAction = sal_False; |
| |
| if (pEntry.isValid() && Controller().Is() && Controller()->IsModified()) |
| { |
| // fuer die Undo-Action |
| String strOldCellContents,sNewValue; |
| long nRow = GetRealRow(GetCurRow()); |
| sal_Bool bAppendRow = sal_False; |
| switch (nRow) |
| { |
| case BROW_VIS_ROW: |
| { |
| sal_Bool bOldValue = m_pVisibleCell->GetBox().GetSavedValue() != STATE_NOCHECK; |
| strOldCellContents = bOldValue ? g_strOne : g_strZero; |
| sNewValue = !bOldValue ? g_strOne : g_strZero; |
| } |
| if((m_bOrderByUnRelated || pEntry->GetOrderDir() == ORDER_NONE) && |
| (m_bGroupByUnRelated || !pEntry->IsGroupBy())) |
| { |
| pEntry->SetVisible(m_pVisibleCell->GetBox().IsChecked()); |
| } |
| else |
| { |
| pEntry->SetVisible(sal_True); |
| m_pVisibleCell->GetBox().Check(); |
| } |
| break; |
| |
| case BROW_FIELD_ROW: |
| { |
| String aFieldName(m_pFieldCell->GetText()); |
| try |
| { |
| if (!aFieldName.Len()) |
| { |
| OTableFieldDescRef pNewEntry = new OTableFieldDesc(); |
| pNewEntry->SetColumnId( pEntry->GetColumnId() ); |
| ::std::replace(getFields().begin(),getFields().end(),pEntry,pNewEntry); |
| sal_uInt16 nCol = GetCurColumnId(); |
| for (int i = 0; i < m_nVisibleCount; i++) // Spalte neu zeichnen |
| RowModified(i,nCol); |
| } |
| else |
| { |
| strOldCellContents = pEntry->GetField(); |
| bListAction = sal_True; |
| if ( !m_bInUndoMode ) |
| rController.GetUndoManager().EnterListAction(String(),String()); |
| |
| sal_uInt16 nPos = m_pFieldCell->GetEntryPos(aFieldName); |
| String aAliasName = pEntry->GetAlias(); |
| if ( nPos != COMBOBOX_ENTRY_NOTFOUND && !aAliasName.Len() && aFieldName.GetTokenCount('.') > 1 ) |
| { // special case, we have a table field so we must cut the table name |
| String sTableAlias = aFieldName.GetToken(0,'.'); |
| pEntry->SetAlias(sTableAlias); |
| String sColumnName = aFieldName.Copy(sTableAlias.Len()+1,aFieldName.Len() - sTableAlias.Len() -1); |
| Reference<XConnection> xConnection = rController.getConnection(); |
| if ( !xConnection.is() ) |
| return sal_False; |
| bError = fillColumnRef( sColumnName, sTableAlias, xConnection->getMetaData(), pEntry, bListAction ); |
| } |
| else |
| bError = sal_True; |
| |
| if ( bError ) |
| bError = saveField(aFieldName,pEntry,bListAction); |
| } |
| } |
| catch(Exception&) |
| { |
| bError = sal_True; |
| } |
| if ( bError ) |
| { |
| sNewValue = aFieldName; |
| if ( !m_bInUndoMode ) |
| static_cast<OQueryController&>(getDesignView()->getController()).GetUndoManager().LeaveListAction(); |
| bListAction = sal_False; |
| } |
| else |
| sNewValue = pEntry->GetField(); |
| rController.InvalidateFeature( ID_BROWSER_QUERY_EXECUTE ); |
| } |
| break; |
| |
| case BROW_TABLE_ROW: |
| { |
| String aAliasName = m_pTableCell->GetSelectEntry(); |
| strOldCellContents = pEntry->GetAlias(); |
| if ( m_pTableCell->GetSelectEntryPos() != 0 ) |
| { |
| pEntry->SetAlias(aAliasName); |
| // we have to set the table name as well as the table window |
| OJoinTableView::OTableWindowMap* pTabWinList = getDesignView()->getTableView()->GetTabWinMap(); |
| if (pTabWinList) |
| { |
| OJoinTableView::OTableWindowMapIterator aIter = pTabWinList->find(aAliasName); |
| if(aIter != pTabWinList->end()) |
| { |
| OQueryTableWindow* pEntryTab = static_cast<OQueryTableWindow*>(aIter->second); |
| if (pEntryTab) |
| { |
| pEntry->SetTable(pEntryTab->GetTableName()); |
| pEntry->SetTabWindow(pEntryTab); |
| } |
| } |
| } |
| } |
| else |
| { |
| pEntry->SetAlias(::rtl::OUString()); |
| pEntry->SetTable(::rtl::OUString()); |
| pEntry->SetTabWindow(NULL); |
| } |
| sNewValue = pEntry->GetAlias(); |
| |
| } break; |
| |
| case BROW_ORDER_ROW: |
| { |
| strOldCellContents = String::CreateFromInt32((sal_uInt16)pEntry->GetOrderDir()); |
| sal_uInt16 nIdx = m_pOrderCell->GetSelectEntryPos(); |
| if (nIdx == sal_uInt16(-1)) |
| nIdx = 0; |
| pEntry->SetOrderDir(EOrderDir(nIdx)); |
| if(!m_bOrderByUnRelated) |
| { |
| pEntry->SetVisible(sal_True); |
| m_pVisibleCell->GetBox().Check(); |
| RowModified(GetBrowseRow(BROW_VIS_ROW), GetCurColumnId()); |
| } |
| sNewValue = String::CreateFromInt32((sal_uInt16)pEntry->GetOrderDir()); |
| } break; |
| |
| case BROW_COLUMNALIAS_ROW: |
| strOldCellContents = pEntry->GetFieldAlias(); |
| pEntry->SetFieldAlias(m_pTextCell->GetText()); |
| sNewValue = pEntry->GetFieldAlias(); |
| break; |
| case BROW_FUNCTION_ROW: |
| { |
| strOldCellContents = pEntry->GetFunction(); |
| sal_uInt16 nPos = m_pFunctionCell->GetSelectEntryPos(); |
| // Diese Funktionen stehen nur unter CORE zur Verfügung |
| String sFunctionName = m_pFunctionCell->GetEntry(nPos); |
| String sGroupFunctionName = m_aFunctionStrings.GetToken(m_aFunctionStrings.GetTokenCount()-1); |
| sal_Bool bGroupBy = sal_False; |
| if ( sGroupFunctionName.Equals(sFunctionName) ) // check if the function name is GROUP |
| { |
| bGroupBy = sal_True; |
| |
| if ( !m_bGroupByUnRelated && !pEntry->IsVisible() ) |
| { |
| // we have to change the visblie flag, so we must append also an undo action |
| pEntry->SetVisible(sal_True); |
| m_pVisibleCell->GetBox().Check(); |
| appendUndoAction(g_strZero,g_strOne,BROW_VIS_ROW,bListAction); |
| RowModified(GetBrowseRow(BROW_VIS_ROW), GetCurColumnId()); |
| } |
| |
| pEntry->SetFunction(String()); |
| pEntry->SetFunctionType(pEntry->GetFunctionType() & ~FKT_AGGREGATE ); |
| } |
| else if ( nPos ) // we found an aggregate function |
| { |
| pEntry->SetFunctionType(pEntry->GetFunctionType() | FKT_AGGREGATE ); |
| pEntry->SetFunction(sFunctionName); |
| } |
| else |
| { |
| sFunctionName = String(); |
| pEntry->SetFunction(String()); |
| pEntry->SetFunctionType(pEntry->GetFunctionType() & ~FKT_AGGREGATE ); |
| } |
| |
| pEntry->SetGroupBy(bGroupBy); |
| |
| sNewValue = sFunctionName; |
| } |
| break; |
| default: |
| { |
| Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection(); |
| if(!xConnection.is()) |
| break; |
| |
| sal_uInt16 nIdx = sal_uInt16(nRow - BROW_CRIT1_ROW); |
| String aText = m_pTextCell->GetText(); |
| |
| aText.EraseLeadingChars(); |
| ::rtl::OUString aCrit; |
| if(aText.Len()) |
| { |
| ::rtl::OUString aErrorMsg; |
| Reference<XPropertySet> xColumn; |
| OSQLParseNode* pParseNode = getDesignView()->getPredicateTreeFromEntry(pEntry,aText,aErrorMsg,xColumn); |
| |
| if (pParseNode) |
| { |
| pParseNode->parseNodeToPredicateStr(aCrit, |
| xConnection, |
| static_cast<OQueryController&>(getDesignView()->getController()).getNumberFormatter(), |
| xColumn, |
| getDesignView()->getLocale(), |
| static_cast<sal_Char>(getDesignView()->getDecimalSeparator().toChar()), |
| &(static_cast<OQueryController&>(getDesignView()->getController()).getParser().getContext())); |
| delete pParseNode; |
| } |
| else |
| { |
| if(xColumn.is()) |
| { |
| sal_Int32 nType = 0; |
| xColumn->getPropertyValue(PROPERTY_TYPE) >>= nType; |
| switch(nType) |
| { |
| case DataType::CHAR: |
| case DataType::VARCHAR: |
| case DataType::LONGVARCHAR: |
| case DataType::CLOB: |
| if(aText.GetChar(0) != '\'' || aText.GetChar(aText.Len() -1) != '\'') |
| { |
| aText.SearchAndReplaceAll(String::CreateFromAscii("'"),String::CreateFromAscii("''")); |
| String aTmp(String::CreateFromAscii("'")); |
| (aTmp += aText) += String::CreateFromAscii("'"); |
| aText = aTmp; |
| } |
| break; |
| default: |
| ; |
| } |
| ::connectivity::OSQLParser& rParser = static_cast<OQueryController&>(getDesignView()->getController()).getParser(); |
| pParseNode = rParser.predicateTree(aErrorMsg, |
| aText, |
| static_cast<OQueryController&>(getDesignView()->getController()).getNumberFormatter(), |
| xColumn); |
| if (pParseNode) |
| { |
| pParseNode->parseNodeToPredicateStr(aCrit, |
| xConnection, |
| static_cast<OQueryController&>(getDesignView()->getController()).getNumberFormatter(), |
| xColumn, |
| getDesignView()->getLocale(), |
| static_cast<sal_Char>(getDesignView()->getDecimalSeparator().toChar()), |
| &(static_cast<OQueryController&>(getDesignView()->getController()).getParser().getContext())); |
| delete pParseNode; |
| } |
| else |
| { |
| if ( !m_bDisableErrorBox ) |
| { |
| OSQLWarningBox( this, aErrorMsg ).Execute(); |
| } |
| bError = sal_True; |
| } |
| } |
| else |
| { |
| if ( !m_bDisableErrorBox ) |
| { |
| OSQLWarningBox( this, aErrorMsg ).Execute(); |
| } |
| bError = sal_True; |
| } |
| } |
| // } |
| } |
| strOldCellContents = pEntry->GetCriteria(nIdx); |
| pEntry->SetCriteria(nIdx, aCrit); |
| sNewValue = pEntry->GetCriteria(nIdx); |
| if(aCrit.getLength() && nRow >= (GetRowCount()-1)) |
| bAppendRow = sal_True; |
| } |
| } |
| if(!bError && Controller()) |
| Controller()->ClearModified(); |
| |
| RowModified(GetCurRow(), GetCurColumnId()); |
| |
| if ( bAppendRow ) |
| { |
| RowInserted( GetRowCount()-1, 1, sal_True ); |
| m_bVisibleRow.push_back(sal_True); |
| ++m_nVisibleCount; |
| } |
| |
| if(!bError) |
| { |
| // und noch die Undo-Action fuer das Ganze |
| appendUndoAction(strOldCellContents,sNewValue,nRow); |
| |
| } |
| } |
| |
| // habe ich Daten in einer FieldDescription gespeichert, die vorher leer war und es nach den Aenderungen nicht mehr ist ? |
| if ( pEntry.isValid() && bWasEmpty && !pEntry->IsEmpty() && !bError ) |
| { |
| // Default auf sichtbar |
| pEntry->SetVisible(sal_True); |
| appendUndoAction(g_strZero,g_strOne,BROW_VIS_ROW,bListAction); |
| RowModified(BROW_VIS_ROW, GetCurColumnId()); |
| |
| // wenn noetig neue freie Spalten anlegen |
| sal_uInt16 nDummy; |
| CheckFreeColumns(nDummy); |
| } |
| |
| if ( bListAction && !m_bInUndoMode ) |
| static_cast<OQueryController&>(getDesignView()->getController()).GetUndoManager().LeaveListAction(); |
| |
| return pEntry != NULL && !bError; |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Bool OSelectionBrowseBox::SeekRow(long nRow) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| sal_Bool bRet = sal_False; |
| |
| m_nSeekRow = nRow; |
| if (nRow < m_nVisibleCount ) |
| bRet = sal_True; |
| |
| return bRet; |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::PaintCell(OutputDevice& rDev, const Rectangle& rRect, sal_uInt16 nColumnId) const |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| rDev.SetClipRegion( rRect ); |
| |
| OTableFieldDescRef pEntry = NULL; |
| sal_uInt16 nPos = GetColumnPos(nColumnId); |
| if(getFields().size() > sal_uInt16(nPos - 1)) |
| pEntry = getFields()[nPos - 1]; |
| |
| if (!pEntry.isValid()) |
| return; |
| |
| long nRow = GetRealRow(m_nSeekRow); |
| if (nRow == BROW_VIS_ROW) |
| PaintTristate(rDev, rRect, pEntry->IsVisible() ? STATE_CHECK : STATE_NOCHECK); |
| else |
| rDev.DrawText(rRect, GetCellText(nRow, nColumnId),TEXT_DRAW_VCENTER); |
| |
| rDev.SetClipRegion( ); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::PaintStatusCell(OutputDevice& rDev, const Rectangle& rRect) const |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| Rectangle aRect(rRect); |
| aRect.TopLeft().Y() -= 2; |
| String aLabel(ModuleRes(STR_QUERY_HANDLETEXT)); |
| |
| // ab BROW_CRIT2_ROW werden alle Zeilen mit "oder" angegeben |
| xub_StrLen nToken = (xub_StrLen) (m_nSeekRow >= GetBrowseRow(BROW_CRIT2_ROW)) |
| ? |
| xub_StrLen(BROW_CRIT2_ROW) : xub_StrLen(GetRealRow(m_nSeekRow)); |
| rDev.DrawText(aRect, aLabel.GetToken(nToken),TEXT_DRAW_VCENTER); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::RemoveColumn(sal_uInt16 _nColumnId) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController()); |
| |
| sal_uInt16 nPos = GetColumnPos(_nColumnId); |
| // das Control sollte immer genau eine Spalte mehr haben, naemlich die HandleColumn |
| DBG_ASSERT((nPos == 0) || (nPos <= getFields().size()), "OSelectionBrowseBox::RemoveColumn : invalid parameter nColId"); |
| // ColId ist bei mir gleichbedeutend mit Position, und da sollte die Bedingung natuerlich zutreffen |
| |
| sal_uInt16 nCurCol = GetCurColumnId(); |
| long nCurrentRow = GetCurRow(); |
| |
| DeactivateCell(); |
| |
| getFields().erase( getFields().begin() + (nPos - 1) ); |
| OTableFieldDescRef pEntry = new OTableFieldDesc(); |
| pEntry->SetColumnId(_nColumnId); |
| getFields().push_back(pEntry); |
| |
| EditBrowseBox::RemoveColumn( _nColumnId ); |
| InsertDataColumn( _nColumnId , String(), DEFAULT_SIZE, HIB_STDSTYLE, HEADERBAR_APPEND); |
| |
| // Neuzeichnen |
| Rectangle aInvalidRect = GetInvalidRect( _nColumnId ); |
| Invalidate( aInvalidRect ); |
| |
| ActivateCell( nCurrentRow, nCurCol ); |
| |
| rController.setModified( sal_True ); |
| |
| invalidateUndoRedo(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::RemoveField(sal_uInt16 nColumnId ) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController()); |
| |
| sal_uInt16 nPos = GetColumnPos(nColumnId); |
| OSL_ENSURE(getFields().size() > sal_uInt16(nPos-1),"ID is to great!"); |
| |
| OTableFieldDescRef pDesc = getEntry((sal_uInt32)(nPos - 1)) ; |
| pDesc->SetColWidth( (sal_uInt16)GetColumnWidth(nColumnId) ); // hat er sich vorher leider nicht gemerkt |
| |
| // UndoAction erzeugen |
| if ( !m_bInUndoMode ) |
| { |
| OTabFieldDelUndoAct* pUndoAction = new OTabFieldDelUndoAct( this ); |
| pUndoAction->SetTabFieldDescr(pDesc); |
| pUndoAction->SetColumnPosition(nPos); |
| rController.addUndoActionAndInvalidate( pUndoAction ); |
| } |
| |
| RemoveColumn(nColumnId); |
| |
| invalidateUndoRedo(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::adjustSelectionMode( sal_Bool _bClickedOntoHeader, sal_Bool _bClickedOntoHandleCol ) |
| { |
| // wenn ein Header selectiert wird, muß die selection angezeigt werden, sonst nicht) |
| if ( _bClickedOntoHeader ) |
| { |
| if (0 == GetSelectColumnCount() ) |
| // wenn es schon eine selektierte Spalte gibt, bin ich schon im richtigen Modus |
| if ( BROWSER_HIDESELECT == ( m_nMode & BROWSER_HIDESELECT ) ) |
| { |
| m_nMode &= ~BROWSER_HIDESELECT; |
| m_nMode |= BROWSER_MULTISELECTION; |
| SetMode( m_nMode ); |
| } |
| } |
| else if ( BROWSER_HIDESELECT != ( m_nMode & BROWSER_HIDESELECT ) ) |
| { |
| if ( GetSelectColumnCount() != 0 ) |
| SetNoSelection(); |
| |
| if ( _bClickedOntoHandleCol ) |
| { |
| m_nMode |= BROWSER_HIDESELECT; |
| m_nMode &= ~BROWSER_MULTISELECTION; |
| SetMode( m_nMode ); |
| } |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::MouseButtonDown(const BrowserMouseEvent& rEvt) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| if( rEvt.IsLeft() ) |
| { |
| sal_Bool bOnHandle = HANDLE_ID == rEvt.GetColumnId(); |
| sal_Bool bOnHeader = ( rEvt.GetRow() < 0 ) && !bOnHandle; |
| adjustSelectionMode( bOnHeader, bOnHandle ); |
| } |
| EditBrowseBox::MouseButtonDown(rEvt); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::MouseButtonUp(const BrowserMouseEvent& rEvt) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| EditBrowseBox::MouseButtonUp( rEvt ); |
| static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( ID_BROWSER_QUERY_EXECUTE ); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::KeyInput( const KeyEvent& rEvt ) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| if (IsColumnSelected(GetCurColumnId())) |
| { |
| if (rEvt.GetKeyCode().GetCode() == KEY_DELETE && // Delete rows |
| !rEvt.GetKeyCode().IsShift() && |
| !rEvt.GetKeyCode().IsMod1()) |
| { |
| RemoveField(GetCurColumnId()); |
| return; |
| } |
| } |
| EditBrowseBox::KeyInput(rEvt); |
| } |
| |
| |
| //------------------------------------------------------------------------------ |
| sal_Int8 OSelectionBrowseBox::AcceptDrop( const BrowserAcceptDropEvent& rEvt ) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| sal_Int8 nDropAction = DND_ACTION_NONE; |
| if ( rEvt.GetRow() >= -1 ) |
| { |
| if ( IsEditing() ) |
| { |
| // #100271# OJ allow the asterix again |
| m_bDisableErrorBox = sal_True; |
| SaveModified(); |
| m_bDisableErrorBox = sal_False; |
| DeactivateCell(); |
| } |
| // check if the format is already supported, if not deactivate the current cell and try again |
| if ( OJoinExchObj::isFormatAvailable(GetDataFlavors()) ) |
| nDropAction = DND_ACTION_LINK; |
| } |
| |
| return nDropAction; |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Int8 OSelectionBrowseBox::ExecuteDrop( const BrowserExecuteDropEvent& _rEvt ) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| |
| TransferableDataHelper aDropped(_rEvt.maDropEvent.Transferable); |
| if (!OJoinExchObj::isFormatAvailable(aDropped.GetDataFlavorExVector())) |
| { |
| DBG_ERROR("OSelectionBrowseBox::ExecuteDrop: this should never have passed AcceptDrop!"); |
| return DND_ACTION_NONE; |
| } |
| |
| OTableFieldDesc aInfo; |
| // Einfuegen des Feldes an der gewuenschten Position |
| OJoinExchangeData jxdSource = OJoinExchObj::GetSourceDescription(_rEvt.maDropEvent.Transferable); |
| InsertField(jxdSource); |
| |
| return DND_ACTION_LINK; |
| } |
| |
| //------------------------------------------------------------------------------ |
| OTableFieldDescRef OSelectionBrowseBox::AppendNewCol( sal_uInt16 nCnt) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| // es koennen mehrere angelegt werden, aber der Erste |
| // wird returnt |
| sal_uInt32 nCount = getFields().size(); |
| for (sal_uInt16 i=0 ; i<nCnt ; i++) |
| { |
| OTableFieldDescRef pEmptyEntry = new OTableFieldDesc(); |
| getFields().push_back(pEmptyEntry); |
| sal_uInt16 nColumnId = sal::static_int_cast< sal_uInt16 >(getFields().size()); |
| pEmptyEntry->SetColumnId( nColumnId ); |
| |
| InsertDataColumn( nColumnId , String(), DEFAULT_SIZE, HIB_STDSTYLE, HEADERBAR_APPEND); |
| } |
| |
| return getFields()[nCount]; |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::DeleteFields(const String& rAliasName) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| if (!getFields().empty()) |
| { |
| sal_uInt16 nColId = GetCurColumnId(); |
| sal_uInt32 nRow = GetCurRow(); |
| |
| sal_Bool bWasEditing = IsEditing(); |
| if (bWasEditing) |
| DeactivateCell(); |
| |
| OTableFields::reverse_iterator aIter = getFields().rbegin(); |
| OTableFieldDescRef pEntry = NULL; |
| for(sal_uInt16 nPos=sal::static_int_cast< sal_uInt16 >(getFields().size());aIter != getFields().rend();++aIter,--nPos) |
| { |
| pEntry = *aIter; |
| if ( pEntry->GetAlias().equals( rAliasName ) ) |
| { |
| RemoveField( GetColumnId( nPos ) ); |
| break; |
| } |
| } |
| |
| if (bWasEditing) |
| ActivateCell(nRow , nColId); |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::SetColWidth(sal_uInt16 nColId, long nNewWidth) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| sal_Bool bWasEditing = IsEditing(); |
| if (bWasEditing) |
| DeactivateCell(); |
| |
| // die Basisklasse machen lassen |
| SetColumnWidth(nColId, nNewWidth); |
| |
| // der FieldDescription Bescheid sagen |
| OTableFieldDescRef pEntry = getEntry(GetColumnPos(nColId) - 1); |
| if (pEntry.isValid()) |
| pEntry->SetColWidth(sal_uInt16(GetColumnWidth(nColId))); |
| |
| if (bWasEditing) |
| ActivateCell(GetCurRow(), GetCurColumnId()); |
| } |
| |
| //------------------------------------------------------------------------------ |
| Rectangle OSelectionBrowseBox::GetInvalidRect( sal_uInt16 nColId ) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| ////////////////////////////////////////////////////////////////////// |
| // Rechteck ist erst einmal der gesamte Outputbereich des Fensters |
| Rectangle aInvalidRect( Point(0,0), GetOutputSizePixel() ); |
| |
| ////////////////////////////////////////////////////////////////////// |
| // Dann wird die linke Seite angepasst |
| Rectangle aFieldRect(GetCellRect( 0, nColId )); // used instead of GetFieldRectPixel |
| aInvalidRect.Left() = aFieldRect.Left(); |
| |
| return aInvalidRect; |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::InsertColumn(OTableFieldDescRef pEntry, sal_uInt16& _nColumnPostion) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| // das Control sollte immer genau eine Spalte mehr haben, naemlich die HandleColumn |
| DBG_ASSERT(_nColumnPostion == BROWSER_INVALIDID || (_nColumnPostion <= (long)getFields().size()), "OSelectionBrowseBox::InsertColumn : invalid parameter nColId."); |
| // -1 heisst ganz hinten, Count heisst ganz hinten, der Rest bezeichnet eine richtige Position |
| |
| sal_uInt16 nCurCol = GetCurColumnId(); |
| long nCurrentRow = GetCurRow(); |
| |
| DeactivateCell(); |
| |
| // remember the column id of the current positon |
| sal_uInt16 nColumnId = GetColumnId(_nColumnPostion); |
| // Wenn zu klein oder zu gross, auf Ende der Liste setzen |
| if ((_nColumnPostion == BROWSER_INVALIDID) || (_nColumnPostion >= getFields().size())) // Anhaengen des Feldes |
| { |
| if (FindFirstFreeCol(_nColumnPostion) == NULL) // keine freie Column mehr |
| { |
| AppendNewCol(1); |
| _nColumnPostion = sal::static_int_cast< sal_uInt16 >( |
| getFields().size()); |
| } |
| else |
| ++_nColumnPostion; // innerhalb der vorgegebenen Liste |
| nColumnId = GetColumnId(_nColumnPostion); |
| pEntry->SetColumnId( nColumnId ); |
| getFields()[ _nColumnPostion - 1] = pEntry; |
| } |
| |
| // check if the column ids are identical, if not we have to move |
| if ( pEntry->GetColumnId() != nColumnId ) |
| { |
| sal_uInt16 nOldPosition = GetColumnPos(pEntry->GetColumnId()); |
| OSL_ENSURE( nOldPosition != 0,"Old position was 0. Not possible!"); |
| SetColumnPos(pEntry->GetColumnId(),_nColumnPostion); |
| // we have to delete an empty field for the fields list, because the columns must have equal length |
| if ( nOldPosition > 0 && nOldPosition <= getFields().size() ) |
| getFields()[nOldPosition - 1] = pEntry; |
| |
| ColumnMoved(pEntry->GetColumnId(),sal_False); |
| } // if ( pEntry->GetColumnId() != nColumnId ) |
| |
| if ( pEntry->GetFunctionType() & (FKT_AGGREGATE) ) |
| { |
| String sFunctionName = pEntry->GetFunction(); |
| if ( GetFunctionName(sal_uInt32(-1),sFunctionName) ) |
| pEntry->SetFunction(sFunctionName); |
| } |
| |
| nColumnId = pEntry->GetColumnId(); |
| |
| SetColWidth(nColumnId,getDesignView()->getColWidth(GetColumnPos(nColumnId)-1)); |
| // Neuzeichnen |
| Rectangle aInvalidRect = GetInvalidRect( nColumnId ); |
| Invalidate( aInvalidRect ); |
| |
| ActivateCell( nCurrentRow, nCurCol ); |
| static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True ); |
| |
| invalidateUndoRedo(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| OTableFieldDescRef OSelectionBrowseBox::InsertField(const OJoinExchangeData& jxdSource, sal_uInt16 _nColumnPostion, sal_Bool bVis, sal_Bool bActivate) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| OQueryTableWindow* pSourceWin = static_cast<OQueryTableWindow*>(jxdSource.pListBox->GetTabWin()); |
| if (!pSourceWin) |
| return NULL; |
| |
| // Namen/Position des selektierten Feldes |
| String aFieldName = jxdSource.pListBox->GetEntryText(jxdSource.pEntry); |
| sal_uInt32 nFieldIndex = jxdSource.pListBox->GetModel()->GetAbsPos(jxdSource.pEntry); |
| OTableFieldInfo* pInf = static_cast<OTableFieldInfo*>(jxdSource.pEntry->GetUserData()); |
| |
| // eine DragInfo aufbauen, damit ich mich auf das andere InsertField zurueckziehen kann |
| OTableFieldDescRef aInfo = new OTableFieldDesc(pSourceWin->GetTableName(),aFieldName); |
| aInfo->SetTabWindow(pSourceWin); |
| aInfo->SetFieldIndex(nFieldIndex); |
| aInfo->SetFieldType(pInf->GetKeyType()); |
| aInfo->SetAlias(pSourceWin->GetAliasName()); |
| |
| aInfo->SetDataType(pInf->GetDataType()); |
| aInfo->SetVisible(bVis); |
| |
| return InsertField(aInfo, _nColumnPostion, bVis, bActivate); |
| } |
| |
| //------------------------------------------------------------------------------ |
| OTableFieldDescRef OSelectionBrowseBox::InsertField(const OTableFieldDescRef& _rInfo, sal_uInt16 _nColumnPostion, sal_Bool bVis, sal_Bool bActivate) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| |
| if(m_nMaxColumns && m_nMaxColumns <= FieldsCount()) |
| return NULL; |
| if (bActivate) |
| SaveModified(); |
| |
| // Neue Spaltenbeschreibung |
| OTableFieldDescRef pEntry = _rInfo; |
| pEntry->SetVisible(bVis); |
| |
| // Spalte einfuegen |
| InsertColumn( pEntry, _nColumnPostion ); |
| |
| if ( !m_bInUndoMode ) |
| { |
| // UndoAction erzeugen |
| OTabFieldCreateUndoAct* pUndoAction = new OTabFieldCreateUndoAct( this ); |
| pUndoAction->SetTabFieldDescr( pEntry ); |
| pUndoAction->SetColumnPosition(_nColumnPostion); |
| getDesignView()->getController().addUndoActionAndInvalidate( pUndoAction ); |
| } |
| |
| return pEntry; |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_uInt16 OSelectionBrowseBox::FieldsCount() |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| OTableFields::iterator aIter = getFields().begin(); |
| sal_uInt16 nCount = 0; |
| |
| while (aIter != getFields().end()) |
| { |
| if ((*aIter).isValid() && !(*aIter)->IsEmpty()) |
| ++nCount; |
| ++aIter; |
| } |
| |
| return nCount; |
| } |
| |
| //------------------------------------------------------------------------------ |
| OTableFieldDescRef OSelectionBrowseBox::FindFirstFreeCol(sal_uInt16& _rColumnPosition ) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| OTableFields::iterator aIter = getFields().begin(); |
| OTableFields::iterator aEnd = getFields().end(); |
| |
| _rColumnPosition = BROWSER_INVALIDID; |
| |
| while ( aIter != aEnd ) |
| { |
| ++_rColumnPosition; |
| OTableFieldDescRef pEntry = (*aIter); |
| if ( pEntry.isValid() && pEntry->IsEmpty() ) |
| return pEntry; |
| ++aIter; |
| } |
| |
| return NULL; |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::CheckFreeColumns(sal_uInt16& _rColumnPosition) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| if (FindFirstFreeCol(_rColumnPosition) == NULL) |
| { |
| // es ist voll, also einen Packen Spalten anhaengen |
| AppendNewCol(DEFAULT_QUERY_COLS); |
| OSL_VERIFY(FindFirstFreeCol(_rColumnPosition).isValid()); |
| } |
| } |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::AddGroupBy( const OTableFieldDescRef& rInfo , sal_uInt32 /*_nCurrentPos*/) |
| { |
| Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection(); |
| if(!xConnection.is()) |
| return; |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| DBG_ASSERT(!rInfo->IsEmpty(),"AddGroupBy:: OTableFieldDescRef sollte nicht Empty sein!"); |
| OTableFieldDescRef pEntry; |
| const Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData(); |
| const ::comphelper::UStringMixEqual bCase(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers()); |
| //sal_Bool bAppend = sal_False; |
| |
| OTableFields& rFields = getFields(); |
| OTableFields::iterator aIter = rFields.begin(); |
| OTableFields::iterator aEnd = rFields.end(); |
| for(;aIter != aEnd;++aIter) |
| { |
| pEntry = *aIter; |
| OSL_ENSURE(pEntry.isValid(),"OTableFieldDescRef was null!"); |
| |
| const ::rtl::OUString aField = pEntry->GetField(); |
| const ::rtl::OUString aAlias = pEntry->GetAlias(); |
| |
| if (bCase(aField,rInfo->GetField()) && |
| bCase(aAlias,rInfo->GetAlias()) && |
| pEntry->GetFunctionType() == rInfo->GetFunctionType() && |
| pEntry->GetFunction() == rInfo->GetFunction()) |
| { |
| if ( pEntry->isNumericOrAggreateFunction() && rInfo->IsGroupBy() ) |
| { |
| pEntry->SetGroupBy(sal_False); |
| aIter = rFields.end(); |
| break; |
| } |
| else |
| { |
| if ( !pEntry->IsGroupBy() && !pEntry->HasCriteria() ) // here we have a where condition which is no having clause |
| { |
| pEntry->SetGroupBy(rInfo->IsGroupBy()); |
| if(!m_bGroupByUnRelated && pEntry->IsGroupBy()) |
| pEntry->SetVisible(sal_True); |
| break; |
| } |
| } |
| |
| } |
| } |
| |
| if (aIter == rFields.end()) |
| { |
| OTableFieldDescRef pTmp = InsertField(rInfo, BROWSER_INVALIDID, sal_False, sal_False ); |
| if ( (pTmp->isNumericOrAggreateFunction() && rInfo->IsGroupBy()) ) // das GroupBy wird bereits von rInfo "ubernommen |
| pTmp->SetGroupBy(sal_False); |
| } |
| } |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::DuplicateConditionLevel( const sal_uInt16 nLevel) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| const sal_uInt16 nNewLevel = nLevel +1; |
| OTableFields& rFields = getFields(); |
| OTableFields::iterator aIter = rFields.begin(); |
| OTableFields::iterator aEnd = rFields.end(); |
| for(;aIter != aEnd;++aIter) |
| { |
| OTableFieldDescRef pEntry = *aIter; |
| |
| ::rtl::OUString sValue = pEntry->GetCriteria(nLevel); |
| if ( sValue.getLength() ) |
| { |
| pEntry->SetCriteria( nNewLevel, sValue); |
| if ( nNewLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1) ) |
| { |
| RowInserted( GetRowCount()-1, 1, sal_True ); |
| m_bVisibleRow.push_back(sal_True); |
| ++m_nVisibleCount; |
| } |
| m_bVisibleRow[BROW_CRIT1_ROW + nNewLevel] = sal_True; |
| } // if (!pEntry->GetCriteria(nLevel).getLength() ) |
| } // for(;aIter != getFields().end();++aIter) |
| } |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::AddCondition( const OTableFieldDescRef& rInfo, const String& rValue, const sal_uInt16 nLevel,bool _bAddOrOnOneLine ) |
| { |
| Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection(); |
| if(!xConnection.is()) |
| return; |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| DBG_ASSERT(rInfo.isValid() && !rInfo->IsEmpty(),"AddCondition:: OTableFieldDescRef sollte nicht Empty sein!"); |
| |
| OTableFieldDescRef pLastEntry; |
| Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData(); |
| ::comphelper::UStringMixEqual bCase(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers()); |
| |
| OTableFields& rFields = getFields(); |
| OTableFields::iterator aIter = rFields.begin(); |
| OTableFields::iterator aEnd = rFields.end(); |
| for(;aIter != aEnd;++aIter) |
| { |
| OTableFieldDescRef pEntry = *aIter; |
| const ::rtl::OUString aField = pEntry->GetField(); |
| const ::rtl::OUString aAlias = pEntry->GetAlias(); |
| |
| if (bCase(aField,rInfo->GetField()) && |
| bCase(aAlias,rInfo->GetAlias()) && |
| pEntry->GetFunctionType() == rInfo->GetFunctionType() && |
| pEntry->GetFunction() == rInfo->GetFunction() && |
| pEntry->IsGroupBy() == rInfo->IsGroupBy() ) |
| { |
| if ( pEntry->isNumericOrAggreateFunction() && rInfo->IsGroupBy() ) |
| pEntry->SetGroupBy(sal_False); |
| else |
| { |
| // pEntry->SetGroupBy(rInfo->IsGroupBy()); |
| if(!m_bGroupByUnRelated && pEntry->IsGroupBy()) |
| pEntry->SetVisible(sal_True); |
| } |
| if (!pEntry->GetCriteria(nLevel).getLength() ) |
| { |
| pEntry->SetCriteria( nLevel, rValue); |
| if(nLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1)) |
| { |
| RowInserted( GetRowCount()-1, 1, sal_True ); |
| m_bVisibleRow.push_back(sal_True); |
| ++m_nVisibleCount; |
| } |
| m_bVisibleRow[BROW_CRIT1_ROW + nLevel] = sal_True; |
| break; |
| } // if (!pEntry->GetCriteria(nLevel).getLength() ) |
| if ( _bAddOrOnOneLine ) |
| { |
| pLastEntry = pEntry; |
| } |
| } |
| } // for(;aIter != getFields().end();++aIter) |
| if ( pLastEntry.isValid() ) |
| { |
| String sCriteria = rValue; |
| String sOldCriteria = pLastEntry->GetCriteria( nLevel ); |
| if ( sOldCriteria.Len() ) |
| { |
| sCriteria = String(RTL_CONSTASCII_USTRINGPARAM("( ")); |
| sCriteria += sOldCriteria; |
| sCriteria += String(RTL_CONSTASCII_USTRINGPARAM(" OR ")); |
| sCriteria += rValue; |
| sCriteria += String(RTL_CONSTASCII_USTRINGPARAM(" )")); |
| } |
| pLastEntry->SetCriteria( nLevel, sCriteria); |
| if(nLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1)) |
| { |
| RowInserted( GetRowCount()-1, 1, sal_True ); |
| m_bVisibleRow.push_back(sal_True); |
| ++m_nVisibleCount; |
| } |
| m_bVisibleRow[BROW_CRIT1_ROW + nLevel] = sal_True; |
| } |
| |
| else if (aIter == getFields().end()) |
| { |
| OTableFieldDescRef pTmp = InsertField(rInfo, BROWSER_INVALIDID, sal_False, sal_False ); |
| if ( pTmp->isNumericOrAggreateFunction() && rInfo->IsGroupBy() ) // das GroupBy wird bereits von rInfo "ubernommen |
| pTmp->SetGroupBy(sal_False); |
| if ( pTmp.isValid() ) |
| { |
| pTmp->SetCriteria( nLevel, rValue); |
| if(nLevel == (m_nVisibleCount-BROW_CRIT1_ROW-1)) |
| { |
| RowInserted( GetRowCount()-1, 1, sal_True ); |
| m_bVisibleRow.push_back(sal_True); |
| ++m_nVisibleCount; |
| } |
| } |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::AddOrder( const OTableFieldDescRef& rInfo, const EOrderDir eDir, sal_uInt32 _nCurrentPos) |
| { |
| Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection(); |
| if(!xConnection.is()) |
| return; |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| DBG_ASSERT(!rInfo->IsEmpty(),"AddOrder:: OTableFieldDescRef sollte nicht Empty sein!"); |
| OTableFieldDescRef pEntry; |
| Reference<XDatabaseMetaData> xMeta = xConnection->getMetaData(); |
| ::comphelper::UStringMixEqual bCase(xMeta.is() && xMeta->supportsMixedCaseQuotedIdentifiers()); |
| |
| sal_Bool bAppend = sal_False; |
| OTableFields& rFields = getFields(); |
| OTableFields::iterator aIter = rFields.begin(); |
| OTableFields::iterator aEnd = rFields.end(); |
| for(;aIter != aEnd;++aIter) |
| { |
| pEntry = *aIter; |
| ::rtl::OUString aField = pEntry->GetField(); |
| ::rtl::OUString aAlias = pEntry->GetAlias(); |
| |
| if (bCase(aField,rInfo->GetField()) && |
| bCase(aAlias,rInfo->GetAlias())) |
| { |
| sal_uInt32 nPos = aIter - rFields.begin(); |
| bAppend = _nCurrentPos > nPos; |
| if ( bAppend ) |
| aIter = rFields.end(); |
| else |
| { |
| if ( !m_bOrderByUnRelated ) |
| pEntry->SetVisible(sal_True); |
| pEntry->SetOrderDir( eDir ); |
| } |
| break; |
| } |
| } |
| |
| if (aIter == rFields.end()) |
| { |
| OTableFieldDescRef pTmp = InsertField(rInfo, BROWSER_INVALIDID, sal_False, sal_False ); |
| if(pTmp.isValid()) |
| { |
| if ( !m_bOrderByUnRelated && !bAppend ) |
| pTmp->SetVisible(sal_True); |
| pTmp->SetOrderDir( eDir ); |
| } |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::ArrangeControls(sal_uInt16& nX, sal_uInt16 nY) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| EditBrowseBox::ArrangeControls(nX, nY); |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Bool OSelectionBrowseBox::Save() |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| sal_Bool bRet = sal_True; |
| if (IsModified()) |
| bRet = SaveModified(); |
| return bRet; |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::CellModified() |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| long nRow = GetRealRow(GetCurRow()); |
| switch (nRow) |
| { |
| case BROW_VIS_ROW: |
| { |
| OTableFieldDescRef pEntry = getEntry(GetColumnPos(GetCurColumnId()) - 1); |
| |
| sal_uInt16 nIdx = m_pOrderCell->GetSelectEntryPos(); |
| if(!m_bOrderByUnRelated && nIdx > 0 && |
| nIdx != sal_uInt16(-1) && |
| !pEntry->IsEmpty() && |
| pEntry->GetOrderDir() != ORDER_NONE) |
| { |
| m_pVisibleCell->GetBox().Check(); |
| pEntry->SetVisible(sal_True); |
| } |
| else |
| pEntry->SetVisible(m_pVisibleCell->GetBox().IsChecked()); |
| } |
| break; |
| } |
| static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True ); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::Fill() |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| DBG_ASSERT(ColCount() >= 1, "OSelectionBrowseBox::Fill : please call only after inserting the handle column !"); |
| |
| sal_uInt16 nColCount = ColCount() - 1; |
| if (nColCount < DEFAULT_QUERY_COLS) |
| AppendNewCol(DEFAULT_QUERY_COLS - nColCount); |
| } |
| |
| //------------------------------------------------------------------------------ |
| Size OSelectionBrowseBox::CalcOptimalSize( const Size& _rAvailable ) |
| { |
| Size aReturn( _rAvailable.Width(), GetTitleHeight() ); |
| |
| aReturn.Height() += ( m_nVisibleCount ? m_nVisibleCount : 15 ) * GetDataRowHeight(); |
| aReturn.Height() += 40; // just some space |
| |
| return aReturn; |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::Command(const CommandEvent& rEvt) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| switch (rEvt.GetCommand()) |
| { |
| case COMMAND_CONTEXTMENU: |
| { |
| Point aMenuPos( rEvt.GetMousePosPixel() ); |
| |
| if (!rEvt.IsMouseEvent()) |
| { |
| if ( 1 == GetSelectColumnCount() ) |
| { |
| sal_uInt16 nSelId = GetColumnId( |
| sal::static_int_cast< sal_uInt16 >( |
| FirstSelectedColumn() ) ); |
| ::Rectangle aColRect( GetFieldRectPixel( 0, nSelId, sal_False ) ); |
| |
| aMenuPos = aColRect.TopCenter(); |
| } |
| else |
| { |
| EditBrowseBox::Command(rEvt); |
| return; |
| } |
| } |
| |
| sal_uInt16 nColId = GetColumnId(GetColumnAtXPosPixel( aMenuPos.X() )); |
| long nRow = GetRowAtYPosPixel( aMenuPos.Y() ); |
| |
| if (nRow < 0 && nColId > HANDLE_ID ) |
| { |
| if ( !IsColumnSelected( nColId ) ) |
| { |
| adjustSelectionMode( sal_True /* clicked onto a header */ , sal_False /* not onto the handle col */ ); |
| SelectColumnId( nColId ); |
| } |
| |
| if (!static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly()) |
| { |
| PopupMenu aContextMenu( ModuleRes( RID_QUERYCOLPOPUPMENU ) ); |
| switch (aContextMenu.Execute(this, aMenuPos)) |
| { |
| case SID_DELETE: |
| RemoveField(nColId); |
| break; |
| |
| case ID_BROWSER_COLWIDTH: |
| adjustBrowseBoxColumnWidth( this, nColId ); |
| break; |
| } |
| } |
| } |
| else if(nRow >= 0 && nColId <= HANDLE_ID) |
| { |
| if (!static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly()) |
| { |
| PopupMenu aContextMenu(ModuleRes(RID_QUERYFUNCTION_POPUPMENU)); |
| aContextMenu.CheckItem( ID_QUERY_FUNCTION, m_bVisibleRow[BROW_FUNCTION_ROW]); |
| aContextMenu.CheckItem( ID_QUERY_TABLENAME, m_bVisibleRow[BROW_TABLE_ROW]); |
| aContextMenu.CheckItem( ID_QUERY_ALIASNAME, m_bVisibleRow[BROW_COLUMNALIAS_ROW]); |
| aContextMenu.CheckItem( ID_QUERY_DISTINCT, static_cast<OQueryController&>(getDesignView()->getController()).isDistinct()); |
| |
| switch (aContextMenu.Execute(this, aMenuPos)) |
| { |
| case ID_QUERY_FUNCTION: |
| SetRowVisible(BROW_FUNCTION_ROW, !IsRowVisible(BROW_FUNCTION_ROW)); |
| static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_VIEW_FUNCTIONS ); |
| break; |
| case ID_QUERY_TABLENAME: |
| SetRowVisible(BROW_TABLE_ROW, !IsRowVisible(BROW_TABLE_ROW)); |
| static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_VIEW_TABLES ); |
| break; |
| case ID_QUERY_ALIASNAME: |
| SetRowVisible(BROW_COLUMNALIAS_ROW, !IsRowVisible(BROW_COLUMNALIAS_ROW)); |
| static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_VIEW_ALIASES ); |
| break; |
| case ID_QUERY_DISTINCT: |
| static_cast<OQueryController&>(getDesignView()->getController()).setDistinct(!static_cast<OQueryController&>(getDesignView()->getController()).isDistinct()); |
| static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True ); |
| static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature( SID_QUERY_DISTINCT_VALUES ); |
| break; |
| } |
| |
| static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True ); |
| } |
| } |
| else |
| { |
| EditBrowseBox::Command(rEvt); |
| return; |
| } |
| } |
| default: |
| EditBrowseBox::Command(rEvt); |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_Bool OSelectionBrowseBox::IsRowVisible(sal_uInt16 _nWhich) const |
| { |
| DBG_ASSERT(_nWhich<(m_bVisibleRow.size()), "OSelectionBrowseBox::IsRowVisible : invalid parameter !"); |
| return m_bVisibleRow[_nWhich]; |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::SetRowVisible(sal_uInt16 _nWhich, sal_Bool _bVis) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| DBG_ASSERT(_nWhich<m_bVisibleRow.size(), "OSelectionBrowseBox::SetRowVisible : invalid parameter !"); |
| |
| sal_Bool bWasEditing = IsEditing(); |
| if (bWasEditing) |
| DeactivateCell(); |
| |
| // do this before removing or inserting rows, as this triggers ActivateCell-calls, which rely on m_bVisibleRow |
| m_bVisibleRow[_nWhich] = !m_bVisibleRow[_nWhich]; |
| |
| long nId = GetBrowseRow(_nWhich); |
| if (_bVis) |
| { |
| RowInserted(nId,1); |
| ++m_nVisibleCount; |
| } |
| else |
| { |
| RowRemoved(nId,1); |
| --m_nVisibleCount; |
| } |
| |
| if (bWasEditing) |
| ActivateCell(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| long OSelectionBrowseBox::GetBrowseRow(long nRowId) const |
| { |
| sal_uInt16 nCount(0); |
| for(sal_uInt16 i = 0 ; i < nRowId ; ++i) |
| { |
| if ( m_bVisibleRow[i] ) |
| ++nCount; |
| } |
| return nCount; |
| } |
| //------------------------------------------------------------------------------ |
| long OSelectionBrowseBox::GetRealRow(long nRowId) const |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| long nErg=0,i; |
| const long nCount = m_bVisibleRow.size(); |
| for(i=0;i < nCount; ++i) |
| { |
| if(m_bVisibleRow[i]) |
| { |
| if(nErg++ == nRowId) |
| break; |
| } |
| } |
| DBG_ASSERT(nErg <= long(m_bVisibleRow.size()),"nErg kann nicht groesser als BROW_ROW_CNT sein!"); |
| return i; |
| } |
| static long nVisibleRowMask[] = |
| { |
| 0x0001, |
| 0x0002, |
| 0x0004, |
| 0x0008, |
| 0x0010, |
| 0x0020, |
| 0x0040, |
| 0x0080, |
| 0x0100, |
| 0x0200, |
| 0x0400, |
| 0x0800 |
| }; |
| //------------------------------------------------------------------------------ |
| sal_Int32 OSelectionBrowseBox::GetNoneVisibleRows() const |
| { |
| sal_Int32 nErg(0); |
| // only the first 11 row are interesting |
| sal_Int32 nSize = sizeof(nVisibleRowMask) / sizeof(nVisibleRowMask[0]); |
| for(sal_Int32 i=0;i<nSize;i++) |
| { |
| if(!m_bVisibleRow[i]) |
| nErg |= nVisibleRowMask[i]; |
| } |
| return nErg; |
| } |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::SetNoneVisbleRow(long nRows) |
| { |
| // only the first 11 row are interesting |
| sal_Int32 nSize = sizeof(nVisibleRowMask) / sizeof(nVisibleRowMask[0]); |
| for(sal_Int32 i=0;i< nSize;i++) |
| m_bVisibleRow[i] = !(nRows & nVisibleRowMask[i]); |
| } |
| //------------------------------------------------------------------------------ |
| String OSelectionBrowseBox::GetCellText(long nRow, sal_uInt16 nColId) const |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| |
| sal_uInt16 nPos = GetColumnPos(nColId); |
| |
| OTableFieldDescRef pEntry = getFields()[nPos-1]; |
| DBG_ASSERT(pEntry != NULL, "OSelectionBrowseBox::GetCellText : invalid column id, prepare for GPF ... "); |
| if ( pEntry->IsEmpty() ) |
| return String(); |
| |
| String aText; |
| switch (nRow) |
| { |
| case BROW_TABLE_ROW: |
| aText = pEntry->GetAlias(); |
| break; |
| case BROW_FIELD_ROW: |
| { |
| String aField = pEntry->GetField(); |
| if (aField.GetChar(0) == '*') // * durch alias.* ersetzen |
| { |
| aField = pEntry->GetAlias(); |
| if(aField.Len()) |
| aField += '.'; |
| aField += '*'; |
| } |
| aText = aField; |
| } break; |
| case BROW_ORDER_ROW: |
| if (pEntry->GetOrderDir() != ORDER_NONE) |
| aText = String(ModuleRes(STR_QUERY_SORTTEXT) ).GetToken(sal::static_int_cast< sal_uInt16 >(pEntry->GetOrderDir())); |
| break; |
| case BROW_VIS_ROW: |
| break; |
| case BROW_COLUMNALIAS_ROW: |
| aText = pEntry->GetFieldAlias(); |
| break; |
| case BROW_FUNCTION_ROW: |
| // we always show the group function at first |
| if ( pEntry->IsGroupBy() ) |
| aText = m_aFunctionStrings.GetToken(m_aFunctionStrings.GetTokenCount()-1); |
| else if ( pEntry->isNumericOrAggreateFunction() ) |
| aText = pEntry->GetFunction(); |
| break; |
| default: |
| aText = pEntry->GetCriteria(sal_uInt16(nRow - BROW_CRIT1_ROW)); |
| } |
| return aText; |
| } |
| //------------------------------------------------------------------------------ |
| sal_Bool OSelectionBrowseBox::GetFunctionName(sal_uInt32 _nFunctionTokenId,String& rFkt) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| sal_Bool bErg=sal_True; |
| String aText; |
| switch(_nFunctionTokenId) |
| { |
| case SQL_TOKEN_COUNT: |
| rFkt = (m_pFunctionCell->GetEntryCount() < 3) ? m_pFunctionCell->GetEntry(1) : m_pFunctionCell->GetEntry(2); |
| break; |
| case SQL_TOKEN_AVG: |
| rFkt = m_pFunctionCell->GetEntry(1); |
| break; |
| case SQL_TOKEN_MAX: |
| rFkt = m_pFunctionCell->GetEntry(3); |
| break; |
| case SQL_TOKEN_MIN: |
| rFkt = m_pFunctionCell->GetEntry(4); |
| break; |
| case SQL_TOKEN_SUM: |
| rFkt = m_pFunctionCell->GetEntry(5); |
| break; |
| case SQL_TOKEN_EVERY: |
| rFkt = m_pFunctionCell->GetEntry(6); |
| break; |
| case SQL_TOKEN_ANY: |
| rFkt = m_pFunctionCell->GetEntry(7); |
| break; |
| case SQL_TOKEN_SOME: |
| rFkt = m_pFunctionCell->GetEntry(8); |
| break; |
| case SQL_TOKEN_STDDEV_POP: |
| rFkt = m_pFunctionCell->GetEntry(9); |
| break; |
| case SQL_TOKEN_STDDEV_SAMP: |
| rFkt = m_pFunctionCell->GetEntry(10); |
| break; |
| case SQL_TOKEN_VAR_SAMP: |
| rFkt = m_pFunctionCell->GetEntry(11); |
| break; |
| case SQL_TOKEN_VAR_POP: |
| rFkt = m_pFunctionCell->GetEntry(12); |
| break; |
| case SQL_TOKEN_COLLECT: |
| rFkt = m_pFunctionCell->GetEntry(13); |
| break; |
| case SQL_TOKEN_FUSION: |
| rFkt = m_pFunctionCell->GetEntry(14); |
| break; |
| case SQL_TOKEN_INTERSECTION: |
| rFkt = m_pFunctionCell->GetEntry(15); |
| break; |
| default: |
| { |
| xub_StrLen nCount = m_aFunctionStrings.GetTokenCount(); |
| xub_StrLen i; |
| for ( i = 0; i < nCount-1; i++) // Gruppierung wird nicht mit gez"ahlt |
| { |
| if(rFkt.EqualsIgnoreCaseAscii(m_aFunctionStrings.GetToken(i))) |
| { |
| rFkt = m_aFunctionStrings.GetToken(i); |
| break; |
| } |
| } |
| if(i == nCount-1) |
| bErg = sal_False; |
| } |
| } |
| |
| return bErg; |
| } |
| //------------------------------------------------------------------------------ |
| String OSelectionBrowseBox::GetCellContents(sal_Int32 nCellIndex, sal_uInt16 nColId) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| // DBG_ASSERT(nCellIndex < (GetRowCount()-1),"CellIndex ist zu gross"); |
| if ( GetCurColumnId() == nColId && !m_bInUndoMode ) |
| SaveModified(); |
| |
| sal_uInt16 nPos = GetColumnPos(nColId); |
| OTableFieldDescRef pEntry = getFields()[nPos - 1]; |
| DBG_ASSERT(pEntry != NULL, "OSelectionBrowseBox::GetCellContents : invalid column id, prepare for GPF ... "); |
| |
| switch (nCellIndex) |
| { |
| case BROW_VIS_ROW : |
| return pEntry->IsVisible() ? g_strOne : g_strZero; |
| case BROW_ORDER_ROW: |
| { |
| sal_uInt16 nIdx = m_pOrderCell->GetSelectEntryPos(); |
| if (nIdx == sal_uInt16(-1)) |
| nIdx = 0; |
| return String(nIdx); |
| } |
| default: |
| return GetCellText(nCellIndex, nColId); |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::SetCellContents(sal_Int32 nRow, sal_uInt16 nColId, const String& strNewText) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| sal_Bool bWasEditing = IsEditing() && (GetCurColumnId() == nColId) && IsRowVisible(static_cast<sal_uInt16>(nRow)) && (GetCurRow() == static_cast<sal_uInt16>(GetBrowseRow(nRow))); |
| if (bWasEditing) |
| DeactivateCell(); |
| |
| sal_uInt16 nPos = GetColumnPos(nColId); |
| OTableFieldDescRef pEntry = getEntry(nPos - 1); |
| DBG_ASSERT(pEntry != NULL, "OSelectionBrowseBox::SetCellContents : invalid column id, prepare for GPF ... "); |
| |
| |
| switch (nRow) |
| { |
| case BROW_VIS_ROW: |
| pEntry->SetVisible(strNewText.Equals(g_strOne)); |
| break; |
| case BROW_FIELD_ROW: |
| pEntry->SetField(strNewText); |
| break; |
| case BROW_TABLE_ROW: |
| pEntry->SetAlias(strNewText); |
| break; |
| case BROW_ORDER_ROW: |
| { |
| sal_uInt16 nIdx = (sal_uInt16)strNewText.ToInt32(); |
| pEntry->SetOrderDir(EOrderDir(nIdx)); |
| } break; |
| case BROW_COLUMNALIAS_ROW: |
| pEntry->SetFieldAlias(strNewText); |
| break; |
| case BROW_FUNCTION_ROW: |
| { |
| String sOldFunctionName = pEntry->GetFunction(); |
| String sGroupFunctionName = m_aFunctionStrings.GetToken(m_aFunctionStrings.GetTokenCount()-1); |
| pEntry->SetFunction(strNewText); |
| // first reset this two member |
| sal_Int32 nFunctionType = pEntry->GetFunctionType(); |
| nFunctionType &= ~FKT_AGGREGATE; |
| pEntry->SetFunctionType(nFunctionType); |
| if ( pEntry->IsGroupBy() && !sGroupFunctionName.EqualsIgnoreCaseAscii(strNewText) ) |
| pEntry->SetGroupBy(sal_False); |
| |
| |
| if ( sGroupFunctionName.EqualsIgnoreCaseAscii(strNewText) ) |
| pEntry->SetGroupBy(sal_True); |
| else if ( strNewText.Len() ) |
| { |
| nFunctionType |= FKT_AGGREGATE; |
| pEntry->SetFunctionType(nFunctionType); |
| } |
| } break; |
| default: |
| pEntry->SetCriteria(sal_uInt16(nRow - BROW_CRIT1_ROW), strNewText); |
| } |
| |
| long nCellIndex = GetRealRow(nRow); |
| if(IsRowVisible(static_cast<sal_uInt16>(nRow))) |
| RowModified(nCellIndex, nColId); |
| |
| // die entsprechende Feld-Beschreibung ist jetzt leer -> Visible auf sal_False (damit das konsistent mit normalen leeren Spalten ist) |
| if (pEntry->IsEmpty()) |
| pEntry->SetVisible(sal_False); |
| |
| if (bWasEditing) |
| ActivateCell(nCellIndex, nColId); |
| |
| static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True ); |
| } |
| //------------------------------------------------------------------------------ |
| sal_uInt32 OSelectionBrowseBox::GetTotalCellWidth(long nRow, sal_uInt16 nColId) const |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| |
| long nRowId = GetRealRow(nRow); |
| if (nRowId == BROW_VIS_ROW) |
| return CHECKBOX_SIZE; |
| else |
| return GetDataWindow().GetTextWidth(GetCellText(nRowId, nColId)); |
| } |
| |
| //------------------------------------------------------------------------------ |
| void OSelectionBrowseBox::ColumnResized(sal_uInt16 nColId) |
| { |
| if (static_cast<OQueryController&>(getDesignView()->getController()).isReadOnly()) |
| return; |
| // The resizing of columns can't be suppressed (BrowseBox doesn't support that) so we have to do this |
| // fake. It's not _that_ bad : the user may change column widths while in read-only mode to see all details |
| // but the changes aren't permanent ... |
| |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| sal_uInt16 nPos = GetColumnPos(nColId); |
| DBG_ASSERT(nPos <= getFields().size(),"ColumnResized:: nColId sollte nicht groesser als List::count sein!"); |
| OTableFieldDescRef pEntry = getEntry(nPos-1); |
| DBG_ASSERT(pEntry.isValid(), "OSelectionBrowseBox::ColumnResized : keine FieldDescription !"); |
| static_cast<OQueryController&>(getDesignView()->getController()).setModified( sal_True ); |
| EditBrowseBox::ColumnResized(nColId); |
| |
| if ( pEntry.isValid()) |
| { |
| if ( !m_bInUndoMode ) |
| { |
| // create the undo action |
| OTabFieldSizedUndoAct* pUndo = new OTabFieldSizedUndoAct(this); |
| pUndo->SetColumnPosition( nPos ); |
| pUndo->SetOriginalWidth(pEntry->GetColWidth()); |
| getDesignView()->getController().addUndoActionAndInvalidate(pUndo); |
| } |
| pEntry->SetColWidth(sal_uInt16(GetColumnWidth(nColId))); |
| } |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_uInt32 OSelectionBrowseBox::GetTotalCellWidth(long nRowId, sal_uInt16 nColId) |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| sal_uInt16 nPos = GetColumnPos(nColId); |
| DBG_ASSERT((nPos == 0) || (nPos <= getFields().size()), "OSelectionBrowseBox::GetTotalCellWidth : invalid parameter nColId"); |
| |
| OTableFieldDescRef pEntry = getFields()[nPos-1]; |
| DBG_ASSERT(pEntry.isValid(), "OSelectionBrowseBox::GetTotalCellWidth : invalid FieldDescription !"); |
| |
| long nRow = GetRealRow(nRowId); |
| String strText(GetCellText(nRow, nColId)); |
| return GetDataWindow().LogicToPixel(Size(GetDataWindow().GetTextWidth(strText),0)).Width(); |
| } |
| |
| //------------------------------------------------------------------------------ |
| sal_uInt16 OSelectionBrowseBox::GetDefaultColumnWidth(const String& /*rName*/) const |
| { |
| DBG_CHKTHIS(OSelectionBrowseBox,NULL); |
| // die Baissklasse macht das von dem Text abhaengig, ich habe aber keine Spaltenueberschriften, daher haette ich |
| // hier gern einen anderen Default-Wert |
| return static_cast<sal_uInt16>(DEFAULT_SIZE); |
| } |
| //------------------------------------------------------------------------------ |
| sal_Bool OSelectionBrowseBox::isCutAllowed() |
| { |
| sal_Bool bCutAllowed = sal_False; |
| long nRow = GetRealRow(GetCurRow()); |
| switch (nRow) |
| { |
| case BROW_VIS_ROW: |
| case BROW_ORDER_ROW: |
| case BROW_TABLE_ROW: |
| case BROW_FUNCTION_ROW: |
| break; |
| case BROW_FIELD_ROW: |
| bCutAllowed = m_pFieldCell->GetSelected().Len() != 0; |
| break; |
| default: |
| bCutAllowed = m_pTextCell->GetSelected().Len() != 0; |
| break; |
| } |
| return bCutAllowed; |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::cut() |
| { |
| String sOldValue = GetCellContents(GetRealRow(GetCurRow()),GetCurColumnId()); |
| long nRow = GetRealRow(GetCurRow()); |
| switch (nRow) |
| { |
| case BROW_FIELD_ROW: |
| m_pFieldCell->Cut(); |
| m_pFieldCell->SetModifyFlag(); |
| break; |
| default: |
| m_pTextCell->Cut(); |
| m_pTextCell->SetModifyFlag(); |
| } |
| SaveModified(); |
| RowModified(GetBrowseRow(nRow), GetCurColumnId()); |
| |
| invalidateUndoRedo(); |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::paste() |
| { |
| long nRow = GetRealRow(GetCurRow()); |
| switch (nRow) |
| { |
| case BROW_FIELD_ROW: |
| m_pFieldCell->Paste(); |
| m_pFieldCell->SetModifyFlag(); |
| break; |
| default: |
| m_pTextCell->Paste(); |
| m_pTextCell->SetModifyFlag(); |
| } |
| RowModified(GetBrowseRow(nRow), GetCurColumnId()); |
| invalidateUndoRedo(); |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool OSelectionBrowseBox::isPasteAllowed() |
| { |
| sal_Bool bPasteAllowed = sal_True; |
| long nRow = GetRealRow(GetCurRow()); |
| switch (nRow) |
| { |
| case BROW_VIS_ROW: |
| case BROW_ORDER_ROW: |
| case BROW_TABLE_ROW: |
| case BROW_FUNCTION_ROW: |
| bPasteAllowed = sal_False; |
| break; |
| } |
| return bPasteAllowed; |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool OSelectionBrowseBox::isCopyAllowed() |
| { |
| return isCutAllowed(); |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::copy() |
| { |
| long nRow = GetRealRow(GetCurRow()); |
| switch (nRow) |
| { |
| case BROW_FIELD_ROW: |
| m_pFieldCell->Copy(); |
| break; |
| default: |
| m_pTextCell->Copy(); |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::appendUndoAction(const String& _rOldValue,const String& _rNewValue,sal_Int32 _nRow,sal_Bool& _bListAction) |
| { |
| if ( !m_bInUndoMode && !_rNewValue.Equals(_rOldValue) ) |
| { |
| if ( !_bListAction ) |
| { |
| _bListAction = sal_True; |
| static_cast<OQueryController&>(getDesignView()->getController()).GetUndoManager().EnterListAction(String(),String()); |
| } |
| appendUndoAction(_rOldValue,_rNewValue,_nRow); |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::appendUndoAction(const String& _rOldValue,const String& _rNewValue,sal_Int32 _nRow) |
| { |
| if ( !m_bInUndoMode && !_rNewValue.Equals(_rOldValue) ) |
| { |
| OTabFieldCellModifiedUndoAct* pUndoAct = new OTabFieldCellModifiedUndoAct(this); |
| pUndoAct->SetCellIndex(_nRow); |
| OSL_ENSURE(GetColumnPos(GetCurColumnId()) != BROWSER_INVALIDID,"Current position isn't valid!"); |
| pUndoAct->SetColumnPosition( GetColumnPos(GetCurColumnId()) ); |
| pUndoAct->SetCellContents(_rOldValue); |
| getDesignView()->getController().addUndoActionAndInvalidate(pUndoAct); |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| IMPL_LINK(OSelectionBrowseBox, OnInvalidateTimer, void*, EMPTYARG) |
| { |
| static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature(SID_CUT); |
| static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature(SID_COPY); |
| static_cast<OQueryController&>(getDesignView()->getController()).InvalidateFeature(SID_PASTE); |
| if(!m_bStopTimer) |
| m_timerInvalidate.Start(); |
| return 0L; |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::stopTimer() |
| { |
| m_bStopTimer = sal_True; |
| if (m_timerInvalidate.IsActive()) |
| m_timerInvalidate.Stop(); |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::startTimer() |
| { |
| m_bStopTimer = sal_False; |
| if (!m_timerInvalidate.IsActive()) |
| m_timerInvalidate.Start(); |
| } |
| // ----------------------------------------------------------------------------- |
| OTableFields& OSelectionBrowseBox::getFields() const |
| { |
| OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController()); |
| return rController.getTableFieldDesc(); |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::enableControl(const OTableFieldDescRef& _rEntry,Window* _pControl) |
| { |
| sal_Bool bEnable = !_rEntry->isCondition(); |
| _pControl->Enable(bEnable); |
| _pControl->EnableInput(bEnable); |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::setTextCellContext(const OTableFieldDescRef& _rEntry,const String& _sText,const rtl::OString& _sHelpId) |
| { |
| m_pTextCell->SetText(_sText); |
| m_pTextCell->ClearModifyFlag(); |
| if (!m_pTextCell->HasFocus()) |
| m_pTextCell->GrabFocus(); |
| |
| enableControl(_rEntry,m_pTextCell); |
| |
| if (m_pTextCell->GetHelpId() != _sHelpId) |
| // da TextCell in verschiedenen Kontexten verwendet wird, muss ich den gecachten HelpText loeschen |
| m_pTextCell->SetHelpText(String()); |
| m_pTextCell->SetHelpId(_sHelpId); |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::invalidateUndoRedo() |
| { |
| OQueryController& rController = static_cast<OQueryController&>(getDesignView()->getController()); |
| rController.InvalidateFeature( ID_BROWSER_UNDO ); |
| rController.InvalidateFeature( ID_BROWSER_REDO ); |
| rController.InvalidateFeature( ID_BROWSER_QUERY_EXECUTE ); |
| } |
| // ----------------------------------------------------------------------------- |
| OTableFieldDescRef OSelectionBrowseBox::getEntry(OTableFields::size_type _nPos) |
| { |
| // we have to check if we need a new entry at this position |
| OTableFields& aFields = getFields(); |
| OSL_ENSURE(aFields.size() > _nPos,"ColID is to great!"); |
| |
| OTableFieldDescRef pEntry = aFields[_nPos]; |
| OSL_ENSURE(pEntry.isValid(),"Invalid entry!"); |
| if ( !pEntry.isValid() ) |
| { |
| pEntry = new OTableFieldDesc(); |
| pEntry->SetColumnId( |
| GetColumnId(sal::static_int_cast< sal_uInt16 >(_nPos+1))); |
| aFields[_nPos] = pEntry; |
| } |
| return pEntry; |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::GetFocus() |
| { |
| if(!IsEditing() && !m_bWasEditing) |
| ActivateCell(); |
| EditBrowseBox::GetFocus(); |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::DeactivateCell(sal_Bool _bUpdate) |
| { |
| m_bWasEditing = sal_True; |
| EditBrowseBox::DeactivateCell(_bUpdate); |
| m_bWasEditing = sal_False; |
| } |
| // ----------------------------------------------------------------------------- |
| ::rtl::OUString OSelectionBrowseBox::GetRowDescription( sal_Int32 _nRow ) const |
| { |
| String aLabel(ModuleRes(STR_QUERY_HANDLETEXT)); |
| |
| // ab BROW_CRIT2_ROW werden alle Zeilen mit "oder" angegeben |
| xub_StrLen nToken = (xub_StrLen) (_nRow >= GetBrowseRow(BROW_CRIT2_ROW)) |
| ? |
| xub_StrLen(BROW_CRIT2_ROW) : xub_StrLen(GetRealRow(_nRow)); |
| return ::rtl::OUString(aLabel.GetToken(nToken)); |
| } |
| // ----------------------------------------------------------------------------- |
| ::rtl::OUString OSelectionBrowseBox::GetAccessibleObjectName( ::svt::AccessibleBrowseBoxObjType _eObjType,sal_Int32 _nPosition) const |
| { |
| ::rtl::OUString sRetText; |
| switch( _eObjType ) |
| { |
| case ::svt::BBTYPE_ROWHEADERCELL: |
| sRetText = GetRowDescription(_nPosition); |
| break; |
| default: |
| sRetText = EditBrowseBox::GetAccessibleObjectDescription(_eObjType,_nPosition); |
| } |
| return sRetText; |
| } |
| // ----------------------------------------------------------------------------- |
| sal_Bool OSelectionBrowseBox::fillEntryTable(OTableFieldDescRef& _pEntry,const ::rtl::OUString& _sTableName) |
| { |
| sal_Bool bRet = sal_False; |
| OJoinTableView::OTableWindowMap* pTabWinList = getDesignView()->getTableView()->GetTabWinMap(); |
| if (pTabWinList) |
| { |
| OJoinTableView::OTableWindowMapIterator aIter = pTabWinList->find(_sTableName); |
| if(aIter != pTabWinList->end()) |
| { |
| OQueryTableWindow* pEntryTab = static_cast<OQueryTableWindow*>(aIter->second); |
| if (pEntryTab) |
| { |
| _pEntry->SetTable(pEntryTab->GetTableName()); |
| _pEntry->SetTabWindow(pEntryTab); |
| bRet = sal_True; |
| } |
| } |
| } |
| return bRet; |
| } |
| // ----------------------------------------------------------------------------- |
| void OSelectionBrowseBox::setFunctionCell(OTableFieldDescRef& _pEntry) |
| { |
| Reference< XConnection> xConnection = static_cast<OQueryController&>(getDesignView()->getController()).getConnection(); |
| if ( xConnection.is() ) |
| { |
| // Diese Funktionen stehen nur unter CORE zur Verfügung |
| if ( lcl_SupportsCoreSQLGrammar(xConnection) ) |
| { |
| // if we have an asterix, no other function than count is allowed |
| m_pFunctionCell->Clear(); |
| m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(0)); |
| if ( isFieldNameAsterix(_pEntry->GetField()) ) |
| m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(2)); // 2 -> COUNT |
| else |
| { |
| xub_StrLen nCount = m_aFunctionStrings.GetTokenCount(); |
| if ( _pEntry->isNumeric() ) |
| --nCount; |
| for (xub_StrLen nIdx = 1; nIdx < nCount; nIdx++) |
| m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(nIdx)); |
| } |
| |
| if ( _pEntry->IsGroupBy() ) |
| { |
| OSL_ENSURE(!_pEntry->isNumeric(),"Not allowed to combine group by and numeric values!"); |
| m_pFunctionCell->SelectEntry(m_pFunctionCell->GetEntry(m_pFunctionCell->GetEntryCount() - 1)); |
| } |
| else if ( m_pFunctionCell->GetEntryPos(String(_pEntry->GetFunction())) != COMBOBOX_ENTRY_NOTFOUND ) |
| m_pFunctionCell->SelectEntry(String(_pEntry->GetFunction())); |
| else |
| m_pFunctionCell->SelectEntryPos(0); |
| |
| enableControl(_pEntry,m_pFunctionCell); |
| } |
| else |
| { |
| // nur COUNT(*) erlaubt |
| sal_Bool bCountRemoved = !isFieldNameAsterix(_pEntry->GetField()); |
| if ( bCountRemoved ) |
| m_pFunctionCell->RemoveEntry(1); |
| |
| if ( !bCountRemoved && m_pFunctionCell->GetEntryCount() < 2) |
| m_pFunctionCell->InsertEntry(m_aFunctionStrings.GetToken(2)); // 2 -> COUNT |
| |
| if(m_pFunctionCell->GetEntryPos(String(_pEntry->GetFunction())) != COMBOBOX_ENTRY_NOTFOUND) |
| m_pFunctionCell->SelectEntry(_pEntry->GetFunction()); |
| else |
| m_pFunctionCell->SelectEntryPos(0); |
| } |
| } |
| } |
| // ----------------------------------------------------------------------------- |
| Reference< XAccessible > OSelectionBrowseBox::CreateAccessibleCell( sal_Int32 _nRow, sal_uInt16 _nColumnPos ) |
| { |
| OTableFieldDescRef pEntry = NULL; |
| if(getFields().size() > sal_uInt16(_nColumnPos - 1)) |
| pEntry = getFields()[_nColumnPos - 1]; |
| |
| if ( _nRow == BROW_VIS_ROW && pEntry.isValid() ) |
| return EditBrowseBox::CreateAccessibleCheckBoxCell( _nRow, _nColumnPos,pEntry->IsVisible() ? STATE_CHECK : STATE_NOCHECK ); |
| |
| return EditBrowseBox::CreateAccessibleCell( _nRow, _nColumnPos ); |
| } |
| // ----------------------------------------------------------------------------- |
| bool OSelectionBrowseBox::HasFieldByAliasName(const ::rtl::OUString& rFieldName, OTableFieldDescRef& rInfo) const |
| { |
| OTableFields& aFields = getFields(); |
| OTableFields::iterator aIter = aFields.begin(); |
| OTableFields::iterator aEnd = aFields.end(); |
| |
| for(;aIter != aEnd;++aIter) |
| { |
| if ( (*aIter)->GetFieldAlias() == rFieldName ) |
| { |
| rInfo.getBody() = (*aIter).getBody(); |
| break; |
| } |
| } |
| return aIter != aEnd; |
| } |
| // ----------------------------------------------------------------------------- |
| |