| /************************************************************** | |
| * | |
| * 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_dbui.hxx" | |
| #ifndef DBAUI_QUERYTABLEVIEW_HXX | |
| #include "JoinTableView.hxx" | |
| #endif | |
| #ifndef _TOOLS_DEBUG_HXX | |
| #include <tools/debug.hxx> | |
| #endif | |
| #ifndef DBAUI_QUERYCONTROLLER_HXX | |
| #include "querycontroller.hxx" | |
| #endif | |
| #ifndef DBAUI_JOINDESIGNVIEW_HXX | |
| #include "JoinDesignView.hxx" | |
| #endif | |
| #ifndef _DBU_QRY_HRC_ | |
| #include "dbu_qry.hrc" | |
| #endif | |
| #ifndef DBAUI_TABLEWINDOW_HXX | |
| #include "TableWindow.hxx" | |
| #endif | |
| //#ifndef DBAUI_QUERY_TABLEWINDOWDATA_HXX | |
| //#include "QTableWindowData.hxx" | |
| //#endif | |
| #ifndef DBAUI_TABLEWINDOWLISTBOX_HXX | |
| #include "TableWindowListBox.hxx" | |
| #endif | |
| #ifndef DBAUI_TABLECONNECTION_HXX | |
| #include "TableConnection.hxx" | |
| #endif | |
| #ifndef DBAUI_TABLECONNECTIONDATA_HXX | |
| #include "TableConnectionData.hxx" | |
| #endif | |
| #ifndef DBAUI_CONNECTIONLINE_HXX | |
| #include "ConnectionLine.hxx" | |
| #endif | |
| #ifndef DBAUI_CONNECTIONLINEDATA_HXX | |
| #include "ConnectionLineData.hxx" | |
| #endif | |
| #ifndef DBACCESS_UI_BROWSER_ID_HXX | |
| #include "browserids.hxx" | |
| #endif | |
| #ifndef _URLBMK_HXX | |
| #include <svl/urlbmk.hxx> | |
| #endif | |
| #ifndef _COM_SUN_STAR_SDBC_XDATABASEMETADATA_HPP_ | |
| #include <com/sun/star/sdbc/XDatabaseMetaData.hpp> | |
| #endif | |
| #ifndef DBAUI_OQUERYMOVETABWINUNDOACT_HXX | |
| #include "QueryMoveTabWinUndoAct.hxx" | |
| #endif | |
| #ifndef DBAUI_QUERYSIZETABWINUNDOACT_HXX | |
| #include "QuerySizeTabWinUndoAct.hxx" | |
| #endif | |
| #ifndef _SV_SVAPP_HXX | |
| #include <vcl/svapp.hxx> | |
| #endif | |
| #ifndef DBAUI_TABLEWINDOWDATA_HXX | |
| #include "TableWindowData.hxx" | |
| #endif | |
| #ifndef DBACCESS_JACCESS_HXX | |
| #include "JAccess.hxx" | |
| #endif | |
| #ifndef _COM_SUN_STAR_ACCESSIBILITY_XACCESSIBLE_HPP_ | |
| #include <com/sun/star/accessibility/XAccessible.hpp> | |
| #endif | |
| #ifndef _COM_SUN_STAR_ACCESSIBILITY_ACCESSIBLEROLE_HPP_ | |
| #include <com/sun/star/accessibility/AccessibleRole.hpp> | |
| #endif | |
| #include <com/sun/star/accessibility/AccessibleEventId.hpp> | |
| #ifndef DBAUI_TOOLS_HXX | |
| #include "UITools.hxx" | |
| #endif | |
| #include <cppuhelper/exc_hlp.hxx> | |
| #include <tools/diagnose_ex.h> | |
| #include <boost/bind.hpp> | |
| #include <algorithm> | |
| #include <functional> | |
| using namespace dbaui; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::sdbc; | |
| using namespace ::com::sun::star::accessibility; | |
| using namespace ::com::sun::star::container; | |
| using namespace ::com::sun::star::lang; | |
| #define LINE_SIZE 50 | |
| //////////////////////////////////////////////////////////////// | |
| // Konstanten fuer das Fensterlayout | |
| #define TABWIN_SPACING_X 17 | |
| #define TABWIN_SPACING_Y 17 | |
| #define TABWIN_WIDTH_STD 120 | |
| #define TABWIN_HEIGHT_STD 120 | |
| DBG_NAME(OScrollWindowHelper) | |
| OScrollWindowHelper::OScrollWindowHelper( Window* pParent) : Window( pParent) | |
| ,m_aHScrollBar( this, WB_HSCROLL|WB_REPEAT|WB_DRAG ) | |
| ,m_aVScrollBar( this, WB_VSCROLL|WB_REPEAT|WB_DRAG ) | |
| ,m_pCornerWindow(new ScrollBarBox(this, WB_3DLOOK)) | |
| ,m_pTableView(NULL) | |
| { | |
| DBG_CTOR(OScrollWindowHelper,NULL); | |
| ////////////////////////////////////////////////////////////////////// | |
| // ScrollBars | |
| GetHScrollBar()->SetRange( Range(0, 1000) ); | |
| GetVScrollBar()->SetRange( Range(0, 1000) ); | |
| GetHScrollBar()->SetLineSize( LINE_SIZE ); | |
| GetVScrollBar()->SetLineSize( LINE_SIZE ); | |
| GetHScrollBar()->Show(); | |
| GetVScrollBar()->Show(); | |
| m_pCornerWindow->Show(); | |
| // normally we should be SCROLL_PANE | |
| SetAccessibleRole(AccessibleRole::SCROLL_PANE); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| OScrollWindowHelper::~OScrollWindowHelper() | |
| { | |
| DBG_DTOR(OScrollWindowHelper,NULL); | |
| ::std::auto_ptr<Window> aTemp(m_pCornerWindow); | |
| m_pCornerWindow = NULL; | |
| m_pTableView = NULL; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OScrollWindowHelper::setTableView(OJoinTableView* _pTableView) | |
| { | |
| m_pTableView = _pTableView; | |
| ////////////////////////////////////////////////////////////////////// | |
| // ScrollBars | |
| GetHScrollBar()->SetScrollHdl( LINK(m_pTableView, OJoinTableView, ScrollHdl) ); | |
| GetVScrollBar()->SetScrollHdl( LINK(m_pTableView, OJoinTableView, ScrollHdl) ); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OScrollWindowHelper::resetRange(const Point& _aSize) | |
| { | |
| Point aPos = PixelToLogic(_aSize); | |
| GetHScrollBar()->SetRange( Range(0, aPos.X() + TABWIN_SPACING_X) ); | |
| GetVScrollBar()->SetRange( Range(0, aPos.Y() + TABWIN_SPACING_Y) ); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OScrollWindowHelper::Resize() | |
| { | |
| Window::Resize(); | |
| Size aTotalOutputSize = GetOutputSizePixel(); | |
| long nHScrollHeight = GetHScrollBar()->GetSizePixel().Height(); | |
| long nVScrollWidth = GetVScrollBar()->GetSizePixel().Width(); | |
| GetHScrollBar()->SetPosSizePixel( | |
| Point( 0, aTotalOutputSize.Height()-nHScrollHeight ), | |
| Size( aTotalOutputSize.Width()-nVScrollWidth, nHScrollHeight ) | |
| ); | |
| GetVScrollBar()->SetPosSizePixel( | |
| Point( aTotalOutputSize.Width()-nVScrollWidth, 0 ), | |
| Size( nVScrollWidth, aTotalOutputSize.Height()-nHScrollHeight ) | |
| ); | |
| m_pCornerWindow->SetPosSizePixel( | |
| Point( aTotalOutputSize.Width() - nVScrollWidth, aTotalOutputSize.Height() - nHScrollHeight), | |
| Size( nVScrollWidth, nHScrollHeight ) | |
| ); | |
| GetHScrollBar()->SetPageSize( aTotalOutputSize.Width() ); | |
| GetHScrollBar()->SetVisibleSize( aTotalOutputSize.Width() ); | |
| GetVScrollBar()->SetPageSize( aTotalOutputSize.Height() ); | |
| GetVScrollBar()->SetVisibleSize( aTotalOutputSize.Height() ); | |
| // adjust the ranges of the scrollbars if necessary | |
| long lRange = GetHScrollBar()->GetRange().Max() - GetHScrollBar()->GetRange().Min(); | |
| if (m_pTableView->GetScrollOffset().X() + aTotalOutputSize.Width() > lRange) | |
| GetHScrollBar()->SetRangeMax(m_pTableView->GetScrollOffset().X() + aTotalOutputSize.Width() + GetHScrollBar()->GetRange().Min()); | |
| lRange = GetVScrollBar()->GetRange().Max() - GetVScrollBar()->GetRange().Min(); | |
| if (m_pTableView->GetScrollOffset().Y() + aTotalOutputSize.Height() > lRange) | |
| GetVScrollBar()->SetRangeMax(m_pTableView->GetScrollOffset().Y() + aTotalOutputSize.Height() + GetVScrollBar()->GetRange().Min()); | |
| m_pTableView->SetPosSizePixel(Point( 0, 0 ),Size( aTotalOutputSize.Width()-nVScrollWidth, aTotalOutputSize.Height()-nHScrollHeight )); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| // ----------------------------------------------------------------------------- | |
| //================================================================== | |
| // class OJoinTableView | |
| //================================================================== | |
| //const long WINDOW_WIDTH = 1000; | |
| //const long WINDOW_HEIGHT = 1000; | |
| DBG_NAME(OJoinTableView); | |
| //------------------------------------------------------------------------------ | |
| OJoinTableView::OJoinTableView( Window* pParent, OJoinDesignView* pView ) | |
| :Window( pParent,WB_BORDER ) | |
| ,DropTargetHelper(this) | |
| ,m_aDragOffset( Point(0,0) ) | |
| ,m_aScrollOffset( Point(0,0) ) | |
| ,m_pDragWin( NULL ) | |
| ,m_pSizingWin( NULL ) | |
| ,m_pSelectedConn( NULL ) | |
| ,m_bTrackingInitiallyMoved(sal_False) | |
| ,m_pLastFocusTabWin(NULL) | |
| ,m_pView( pView ) | |
| ,m_pAccessible(NULL) | |
| { | |
| DBG_CTOR(OJoinTableView,NULL); | |
| SetSizePixel( Size(1000, 1000) ); | |
| InitColors(); | |
| m_aDragScrollTimer.SetTimeoutHdl(LINK(this, OJoinTableView, OnDragScrollTimer)); | |
| } | |
| //------------------------------------------------------------------------------ | |
| OJoinTableView::~OJoinTableView() | |
| { | |
| DBG_DTOR(OJoinTableView,NULL); | |
| if( m_pAccessible ) | |
| { | |
| m_pAccessible->clearTableView(); | |
| m_pAccessible = NULL; | |
| } | |
| ////////////////////////////////////////////////////////////////////// | |
| // Listen loeschen | |
| clearLayoutInformation(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| IMPL_LINK( OJoinTableView, ScrollHdl, ScrollBar*, pScrollBar ) | |
| { | |
| ////////////////////////////////////////////////////////////////////// | |
| // Alle Fenster verschieben | |
| ScrollPane( pScrollBar->GetDelta(), (pScrollBar == GetHScrollBar()), sal_False ); | |
| return 0; | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::Resize() | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| Window::Resize(); | |
| m_aOutputSize = GetSizePixel(); | |
| // tab win positions may not be up-to-date | |
| if (m_aTableMap.empty()) | |
| // no tab wins ... | |
| return; | |
| // we have at least one table so resize it | |
| m_aScrollOffset.X() = GetHScrollBar()->GetThumbPos(); | |
| m_aScrollOffset.Y() = GetVScrollBar()->GetThumbPos(); | |
| OTableWindow* pCheck = m_aTableMap.begin()->second; | |
| Point aRealPos = pCheck->GetPosPixel(); | |
| Point aAssumedPos = pCheck->GetData()->GetPosition() - GetScrollOffset(); | |
| if (aRealPos == aAssumedPos) | |
| // all ok | |
| return; | |
| OTableWindowMapIterator aIter = m_aTableMap.begin(); | |
| OTableWindowMapIterator aEnd = m_aTableMap.end(); | |
| for(;aIter != aEnd;++aIter) | |
| { | |
| OTableWindow* pCurrent = aIter->second; | |
| Point aPos(pCurrent->GetData()->GetPosition() - GetScrollOffset()); | |
| pCurrent->SetPosPixel(aPos); | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| sal_uLong OJoinTableView::GetTabWinCount() | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| return m_aTableMap.size(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| bool OJoinTableView::RemoveConnection( OTableConnection* _pConn,sal_Bool _bDelete ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| DeselectConn(_pConn); | |
| // to force a redraw | |
| _pConn->InvalidateConnection(); | |
| m_pView->getController().removeConnectionData( _pConn->GetData() ); | |
| m_vTableConnection.erase( | |
| ::std::find(m_vTableConnection.begin(),m_vTableConnection.end(),_pConn) ); | |
| modified(); | |
| if ( m_pAccessible ) | |
| m_pAccessible->notifyAccessibleEvent( AccessibleEventId::CHILD, | |
| makeAny(_pConn->GetAccessible()), | |
| Any()); | |
| if ( _bDelete ) | |
| { | |
| delete _pConn; | |
| } | |
| return true; | |
| } | |
| //------------------------------------------------------------------------ | |
| OTableWindow* OJoinTableView::GetTabWindow( const String& rName ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| OTableWindowMapIterator aIter = m_aTableMap.find(rName); | |
| return aIter == m_aTableMap.end() ? NULL : aIter->second; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| TTableWindowData::value_type OJoinTableView::createTableWindowData(const ::rtl::OUString& _rComposedName | |
| ,const ::rtl::OUString& _sTableName | |
| ,const ::rtl::OUString& _rWinName) | |
| { | |
| TTableWindowData::value_type pData( CreateImpl(_rComposedName, _sTableName,_rWinName) ); | |
| OJoinDesignView* pParent = getDesignView(); | |
| try | |
| { | |
| if ( !pData->init(pParent->getController().getConnection(),allowQueries()) ) | |
| { | |
| if ( pData->isValid() ) | |
| onNoColumns_throw(); | |
| else | |
| pData.reset(); | |
| } | |
| } | |
| catch ( const SQLException& ) | |
| { | |
| ::dbaui::showError( ::dbtools::SQLExceptionInfo( ::cppu::getCaughtException() ), | |
| pParent, pParent->getController().getORB() ); | |
| } | |
| catch( const WrappedTargetException& e ) | |
| { | |
| SQLException aSql; | |
| if ( e.TargetException >>= aSql ) | |
| ::dbaui::showError( ::dbtools::SQLExceptionInfo( aSql ), pParent, pParent->getController().getORB() ); | |
| } | |
| catch( const Exception& ) | |
| { | |
| DBG_UNHANDLED_EXCEPTION(); | |
| } | |
| return pData; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| OTableWindowData* OJoinTableView::CreateImpl(const ::rtl::OUString& _rComposedName | |
| ,const ::rtl::OUString& _sTableName | |
| ,const ::rtl::OUString& _rWinName) | |
| { | |
| return new OTableWindowData( NULL,_rComposedName,_sTableName, _rWinName ); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::AddTabWin(const ::rtl::OUString& _rComposedName, const ::rtl::OUString& rWinName, sal_Bool /*bNewTable*/) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| OSL_ENSURE(_rComposedName.getLength(),"There must be a table name supplied!"); | |
| TTableWindowData::value_type pNewTabWinData(createTableWindowData( _rComposedName, rWinName,rWinName )); | |
| ////////////////////////////////////////////////////////////////// | |
| // Neues Fenster in Fensterliste eintragen | |
| OTableWindow* pNewTabWin = createWindow( pNewTabWinData ); | |
| if ( pNewTabWin->Init() ) | |
| { | |
| m_pView->getController().getTableWindowData()->push_back( pNewTabWinData); | |
| // when we already have a table with this name insert the full qualified one instead | |
| if(m_aTableMap.find(rWinName) != m_aTableMap.end()) | |
| m_aTableMap[_rComposedName] = pNewTabWin; | |
| else | |
| m_aTableMap[rWinName] = pNewTabWin; | |
| SetDefaultTabWinPosSize( pNewTabWin ); | |
| pNewTabWin->Show(); | |
| modified(); | |
| if ( m_pAccessible ) | |
| m_pAccessible->notifyAccessibleEvent( AccessibleEventId::CHILD, | |
| Any(), | |
| makeAny(pNewTabWin->GetAccessible())); | |
| } | |
| else | |
| { | |
| pNewTabWin->clearListBox(); | |
| delete pNewTabWin; | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::RemoveTabWin( OTableWindow* pTabWin ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| ////////////////////////////////////////////////////////////////////// | |
| // first delete all connections of this window to others | |
| bool bRemove = true; | |
| TTableWindowData::value_type pData = pTabWin->GetData(); | |
| sal_Int32 nCount = m_vTableConnection.size(); | |
| ::std::vector<OTableConnection*>::reverse_iterator aIter = m_vTableConnection.rbegin(); | |
| while(aIter != m_vTableConnection.rend() && bRemove) | |
| { | |
| OTableConnection* pTabConn = (*aIter); | |
| if( | |
| ( pData == pTabConn->GetData()->getReferencingTable()) || | |
| ( pData == pTabConn->GetData()->getReferencedTable()) | |
| ) | |
| { | |
| bRemove = RemoveConnection( pTabConn ,sal_True); | |
| aIter = m_vTableConnection.rbegin(); | |
| } | |
| else | |
| ++aIter; | |
| } | |
| ////////////////////////////////////////////////////////////////////// | |
| // then delete the window itself | |
| if ( bRemove ) | |
| { | |
| if ( m_pAccessible ) | |
| m_pAccessible->notifyAccessibleEvent( AccessibleEventId::CHILD, | |
| makeAny(pTabWin->GetAccessible()),Any() | |
| ); | |
| pTabWin->Hide(); | |
| OJoinController& rController = m_pView->getController(); | |
| TTableWindowData::iterator aFind = ::std::find(rController.getTableWindowData()->begin(),rController.getTableWindowData()->end(),pData); | |
| if(aFind != rController.getTableWindowData()->end()) | |
| { | |
| rController.getTableWindowData()->erase(aFind); | |
| rController.setModified(sal_True); | |
| } | |
| String aWinName = pTabWin->GetWinName(); | |
| if(m_aTableMap.find(aWinName) != m_aTableMap.end()) | |
| m_aTableMap.erase( aWinName ); | |
| else | |
| m_aTableMap.erase( pTabWin->GetComposedName() ); | |
| if (pTabWin == m_pLastFocusTabWin) | |
| m_pLastFocusTabWin = NULL; | |
| pTabWin->clearListBox(); | |
| delete pTabWin; | |
| } | |
| if ( (sal_Int32)m_vTableConnection.size() < (nCount-1) ) // if some connections could be removed | |
| modified(); | |
| } | |
| namespace | |
| { | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool isScrollAllowed( OJoinTableView* _pView,long nDelta, sal_Bool bHoriz) | |
| { | |
| sal_Bool bRet = sal_True; | |
| ////////////////////////////////////////////////////////////////////// | |
| // adjust ScrollBar-Positions | |
| ScrollBar* pBar = _pView->GetVScrollBar(); | |
| if( bHoriz ) | |
| pBar = _pView->GetHScrollBar(); | |
| long nOldThumbPos = pBar->GetThumbPos(); | |
| long nNewThumbPos = nOldThumbPos + nDelta; | |
| if( nNewThumbPos < 0 ) | |
| nNewThumbPos = 0;// bRet = sal_False; | |
| else if( nNewThumbPos > pBar->GetRangeMax() ) | |
| nNewThumbPos = pBar->GetRangeMax();// bRet = sal_False; | |
| if ( bHoriz ) | |
| { | |
| if( nNewThumbPos == _pView->GetScrollOffset().X() ) | |
| return sal_False; | |
| } | |
| else if ( nNewThumbPos == _pView->GetScrollOffset().Y() ) | |
| return sal_False; | |
| return bRet; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool getMovementImpl(OJoinTableView* _pView,const Point& _rPoint,const Size& _rSize,long& _nScrollX,long& _nScrollY) | |
| { | |
| _nScrollY = _nScrollX = 0; | |
| // data about the tab win | |
| Point aUpperLeft = _rPoint; | |
| // normalize with respect to visibility | |
| aUpperLeft -= _pView->GetScrollOffset(); | |
| // aUpperLeft.Y() -= _pView->GetScrollOffset().Y(); | |
| Point aLowerRight(aUpperLeft.X() + _rSize.Width(), aUpperLeft.Y() + _rSize.Height()); | |
| // data about ourself | |
| Size aSize = _pView->getRealOutputSize(); //GetOutputSizePixel(); | |
| sal_Bool bVisbile = sal_True; | |
| sal_Bool bFitsHor = (aUpperLeft.X() >= 0) && (aLowerRight.X() <= aSize.Width()); | |
| sal_Bool bFitsVert= (aUpperLeft.Y() >= 0) && (aLowerRight.Y() <= aSize.Height()); | |
| if (!bFitsHor || !bFitsVert) | |
| { | |
| // #100386# OJ | |
| if (!bFitsHor) | |
| { | |
| // ensure the visibility of the right border | |
| if ( aLowerRight.X() > aSize.Width() ) | |
| _nScrollX = aLowerRight.X() - aSize.Width() + TABWIN_SPACING_X; | |
| // ensure the visibility of the left border (higher priority) | |
| // if ( (aUpperLeft.X() - _nScrollX) < 0 ) | |
| if ( aUpperLeft.X() < 0 ) | |
| _nScrollX = aUpperLeft.X() - TABWIN_SPACING_X; | |
| } | |
| if (!bFitsVert) | |
| { | |
| // lower border | |
| if ( aLowerRight.Y() > aSize.Height() ) | |
| _nScrollY = aLowerRight.Y() - aSize.Height() + TABWIN_SPACING_Y; | |
| // upper border | |
| // if ( (aUpperLeft.Y() - _nScrollY) < 0 ) | |
| if ( aUpperLeft.Y() < 0 ) | |
| _nScrollY = aUpperLeft.Y() - TABWIN_SPACING_Y; | |
| } | |
| if ( _nScrollX ) // aSize.Width() > _rSize.Width() && | |
| bVisbile = isScrollAllowed(_pView,_nScrollX, sal_True); | |
| if ( _nScrollY ) // aSize.Height() > _rSize.Height() && | |
| bVisbile = bVisbile && isScrollAllowed(_pView,_nScrollY, sal_False); | |
| if ( bVisbile ) | |
| { | |
| sal_Int32 nHRangeMax = _pView->GetHScrollBar()->GetRangeMax(); | |
| sal_Int32 nVRangeMax = _pView->GetVScrollBar()->GetRangeMax(); | |
| if ( aSize.Width() + _pView->GetHScrollBar()->GetThumbPos() + _nScrollX > nHRangeMax ) | |
| bVisbile = sal_False; | |
| if ( bVisbile && aSize.Height() + _pView->GetVScrollBar()->GetThumbPos() + _nScrollY > nVRangeMax ) | |
| bVisbile = sal_False; | |
| } | |
| } | |
| return bVisbile; | |
| } | |
| } // end of ano namespace | |
| // ----------------------------------------------------------------------------- | |
| sal_Bool OJoinTableView::isMovementAllowed(const Point& _rPoint,const Size& _rSize) | |
| { | |
| long nX,nY; | |
| return getMovementImpl(this,_rPoint,_rSize,nX,nY); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::EnsureVisible(const OTableWindow* _pWin) | |
| { | |
| // data about the tab win | |
| TTableWindowData::value_type pData = _pWin->GetData(); | |
| // Point aUpperLeft = pData->GetPosition(); | |
| EnsureVisible( pData->GetPosition() , pData->GetSize()); | |
| Invalidate(INVALIDATE_NOCHILDREN); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::EnsureVisible(const Point& _rPoint,const Size& _rSize) | |
| { | |
| long nScrollX,nScrollY; | |
| if ( getMovementImpl(this,_rPoint,_rSize,nScrollX,nScrollY) ) | |
| { | |
| sal_Bool bVisbile = sal_True; | |
| if (nScrollX) | |
| bVisbile = ScrollPane(nScrollX, sal_True, sal_True); | |
| if (nScrollY) | |
| bVisbile = bVisbile && ScrollPane(nScrollY, sal_False, sal_True); | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::SetDefaultTabWinPosSize( OTableWindow* pTabWin ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| ////////////////////////////////////////////////////////////////// | |
| // Position bestimmen: | |
| // Das Fenster wird in Zeilen der Hoehe TABWIN_SPACING_Y+TABWIN_HEIGTH_STD aufgeteilt. | |
| // Dann wird fuer jede Zeile geprueft, ob noch Platz fuer ein weiteres Fenster ist. | |
| // Wenn kein Platz ist, wird die naechste Zeile ueberprueft. | |
| Size aOutSize = GetSizePixel(); | |
| Point aNewPos( 0,0 ); | |
| sal_uInt16 nRow = 0; | |
| sal_Bool bEnd = sal_False; | |
| while( !bEnd ) | |
| { | |
| ////////////////////////////////////////////////////////////////// | |
| // Neue Position auf Zeilenbeginn setzen | |
| aNewPos.X() = TABWIN_SPACING_X; | |
| aNewPos.Y() = (nRow+1) * TABWIN_SPACING_Y; | |
| ////////////////////////////////////////////////////////////////// | |
| // Rectangle fuer die jeweilige Zeile bestimmen | |
| Rectangle aRowRect( Point(0,0), aOutSize ); | |
| aRowRect.Top() = nRow * ( TABWIN_SPACING_Y + TABWIN_HEIGHT_STD ); | |
| aRowRect.Bottom() = (nRow+1) * ( TABWIN_SPACING_Y + TABWIN_HEIGHT_STD ); | |
| ////////////////////////////////////////////////////////////////// | |
| // Belegte Bereiche dieser Zeile pruefen | |
| OTableWindow* pOtherTabWin;// = GetTabWinMap()->First(); | |
| OTableWindowMapIterator aIter = m_aTableMap.begin(); | |
| OTableWindowMapIterator aEnd = m_aTableMap.end(); | |
| for(;aIter != aEnd;++aIter) | |
| { | |
| pOtherTabWin = aIter->second; | |
| Rectangle aOtherTabWinRect( pOtherTabWin->GetPosPixel(), pOtherTabWin->GetSizePixel() ); | |
| if( | |
| ( (aOtherTabWinRect.Top()>aRowRect.Top()) && (aOtherTabWinRect.Top()<aRowRect.Bottom()) ) || | |
| ( (aOtherTabWinRect.Bottom()>aRowRect.Top()) && (aOtherTabWinRect.Bottom()<aRowRect.Bottom()) ) | |
| ) | |
| { | |
| ////////////////////////////////////////////////////////////////// | |
| // TabWin liegt in der Zeile | |
| if( aOtherTabWinRect.Right()>aNewPos.X() ) | |
| aNewPos.X() = aOtherTabWinRect.Right() + TABWIN_SPACING_X; | |
| } | |
| } | |
| ////////////////////////////////////////////////////////////////// | |
| // Ist in dieser Zeile noch Platz? | |
| if( (aNewPos.X()+TABWIN_WIDTH_STD)<aRowRect.Right() ) | |
| { | |
| aNewPos.Y() = aRowRect.Top() + TABWIN_SPACING_Y; | |
| bEnd = sal_True; | |
| } | |
| else | |
| { | |
| if( (aRowRect.Bottom()+aRowRect.GetHeight()) > aOutSize.Height() ) | |
| { | |
| // insert it in the first row | |
| sal_Int32 nCount = m_aTableMap.size() % (nRow+1); | |
| ++nCount; | |
| aNewPos.Y() = nCount * TABWIN_SPACING_Y + (nCount-1)*CalcZoom(TABWIN_HEIGHT_STD); | |
| bEnd = sal_True; | |
| } | |
| else | |
| nRow++; | |
| } | |
| } | |
| ////////////////////////////////////////////////////////////////// | |
| // Groesse bestimmen | |
| Size aNewSize( CalcZoom(TABWIN_WIDTH_STD), CalcZoom(TABWIN_HEIGHT_STD) ); | |
| // check if the new position in inside the scrollbars ranges | |
| Point aBottom(aNewPos); | |
| aBottom.X() += aNewSize.Width(); | |
| aBottom.Y() += aNewSize.Height(); | |
| if(!GetHScrollBar()->GetRange().IsInside(aBottom.X())) | |
| GetHScrollBar()->SetRange( Range(0, aBottom.X()) ); | |
| if(!GetVScrollBar()->GetRange().IsInside(aBottom.Y())) | |
| GetVScrollBar()->SetRange( Range(0, aBottom.Y()) ); | |
| pTabWin->SetPosSizePixel( aNewPos, aNewSize ); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::DataChanged(const DataChangedEvent& rDCEvt) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| if (rDCEvt.GetType() == DATACHANGED_SETTINGS) | |
| { | |
| // nehmen wir den worst-case an : die Farben haben sich geaendert, also | |
| // mich anpassen | |
| InitColors(); | |
| Invalidate(INVALIDATE_NOCHILDREN); | |
| // durch das Invalidate werden auch die Connections neu gezeichnet, so dass die auch | |
| // gleich in den neuen Farben dargestellt werden | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::InitColors() | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| // die Farben fuer die Darstellung sollten die Systemfarben sein | |
| StyleSettings aSystemStyle = Application::GetSettings().GetStyleSettings(); | |
| SetBackground(Wallpaper(Color(aSystemStyle.GetDialogColor()))); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::BeginChildMove( OTableWindow* pTabWin, const Point& rMousePos ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| if (m_pView->getController().isReadOnly()) | |
| return; | |
| m_pDragWin = pTabWin; | |
| SetPointer(Pointer(POINTER_MOVE)); | |
| Point aMousePos = ScreenToOutputPixel( rMousePos ); | |
| m_aDragOffset = aMousePos - pTabWin->GetPosPixel(); | |
| m_pDragWin->SetZOrder(NULL, WINDOW_ZORDER_FIRST); | |
| m_bTrackingInitiallyMoved = sal_False; | |
| StartTracking(); | |
| } | |
| void OJoinTableView::NotifyTitleClicked( OTableWindow* pTabWin, const Point rMousePos ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| DeselectConn(GetSelectedConn()); | |
| BeginChildMove(pTabWin, rMousePos); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::BeginChildSizing( OTableWindow* pTabWin, const Pointer& rPointer ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| if (m_pView->getController().isReadOnly()) | |
| return; | |
| SetPointer( rPointer ); | |
| m_pSizingWin = pTabWin; | |
| StartTracking(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| sal_Bool OJoinTableView::ScrollPane( long nDelta, sal_Bool bHoriz, sal_Bool bPaintScrollBars ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| sal_Bool bRet = sal_True; | |
| ////////////////////////////////////////////////////////////////////// | |
| // ScrollBar-Positionen anpassen | |
| if( bPaintScrollBars ) | |
| { | |
| if( bHoriz ) | |
| { | |
| long nOldThumbPos = GetHScrollBar()->GetThumbPos(); | |
| long nNewThumbPos = nOldThumbPos + nDelta; | |
| if( nNewThumbPos < 0 ) | |
| { | |
| nNewThumbPos = 0; | |
| bRet = sal_False; | |
| } | |
| if( nNewThumbPos > GetHScrollBar()->GetRange().Max() ) | |
| { | |
| nNewThumbPos = GetHScrollBar()->GetRange().Max(); | |
| bRet = sal_False; | |
| } | |
| GetHScrollBar()->SetThumbPos( nNewThumbPos ); | |
| nDelta = GetHScrollBar()->GetThumbPos() - nOldThumbPos; | |
| } | |
| else | |
| { | |
| long nOldThumbPos = GetVScrollBar()->GetThumbPos(); | |
| long nNewThumbPos = nOldThumbPos+nDelta; | |
| if( nNewThumbPos < 0 ) | |
| { | |
| nNewThumbPos = 0; | |
| bRet = sal_False; | |
| } | |
| if( nNewThumbPos > GetVScrollBar()->GetRange().Max() ) | |
| { | |
| nNewThumbPos = GetVScrollBar()->GetRange().Max(); | |
| bRet = sal_False; | |
| } | |
| GetVScrollBar()->SetThumbPos( nNewThumbPos ); | |
| nDelta = GetVScrollBar()->GetThumbPos() - nOldThumbPos; | |
| } | |
| } | |
| ////////////////////////////////////////////////////////////////////// | |
| // Wenn ScrollOffset bereits an den Grenzen liegt, kein Neuzeichnen | |
| if( (GetHScrollBar()->GetThumbPos()==m_aScrollOffset.X()) && | |
| (GetVScrollBar()->GetThumbPos()==m_aScrollOffset.Y()) ) | |
| return sal_False; | |
| ////////////////////////////////////////////////////////////////////// | |
| // ScrollOffset neu setzen | |
| if (bHoriz) | |
| m_aScrollOffset.X() = GetHScrollBar()->GetThumbPos(); | |
| else | |
| m_aScrollOffset.Y() = GetVScrollBar()->GetThumbPos(); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Alle Fenster verschieben | |
| OTableWindow* pTabWin; | |
| Point aPos; | |
| OTableWindowMapIterator aIter = m_aTableMap.begin(); | |
| OTableWindowMapIterator aEnd = m_aTableMap.end(); | |
| for(;aIter != aEnd;++aIter) | |
| { | |
| pTabWin = aIter->second; | |
| aPos = pTabWin->GetPosPixel(); | |
| if( bHoriz ) | |
| aPos.X() -= nDelta; | |
| else aPos.Y() -= nDelta; | |
| pTabWin->SetPosPixel( aPos ); | |
| } | |
| Invalidate(); // INVALIDATE_NOCHILDREN | |
| return bRet; | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::Tracking( const TrackingEvent& rTEvt ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| HideTracking(); | |
| if (rTEvt.IsTrackingEnded()) | |
| { | |
| if( m_pDragWin ) | |
| { | |
| if (m_aDragScrollTimer.IsActive()) | |
| m_aDragScrollTimer.Stop(); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Position des Childs nach Verschieben anpassen | |
| ////////////////////////////////////////////////////////////////////// | |
| // Fenster duerfen nicht aus Anzeigebereich herausbewegt werden | |
| Point aDragWinPos = rTEvt.GetMouseEvent().GetPosPixel() - m_aDragOffset; | |
| Size aDragWinSize = m_pDragWin->GetSizePixel(); | |
| if( aDragWinPos.X() < 0 ) | |
| aDragWinPos.X() = 0; | |
| if( aDragWinPos.Y() < 0 ) | |
| aDragWinPos.Y() = 0; | |
| if( (aDragWinPos.X() + aDragWinSize.Width()) > m_aOutputSize.Width() ) | |
| aDragWinPos.X() = m_aOutputSize.Width() - aDragWinSize.Width() - 1; | |
| if( (aDragWinPos.Y() + aDragWinSize.Height()) > m_aOutputSize.Height() ) | |
| aDragWinPos.Y() = m_aOutputSize.Height() - aDragWinSize.Height() - 1; | |
| if( aDragWinPos.X() < 0 ) | |
| aDragWinPos.X() = 0; | |
| if( aDragWinPos.Y() < 0 ) | |
| aDragWinPos.Y() = 0; | |
| // TODO : nicht das Fenster neu positionieren, wenn es uebersteht, sondern einfach meinen Bereich erweitern | |
| ////////////////////////////////////////////////////////////////////// | |
| // Fenster positionieren | |
| EndTracking(); | |
| m_pDragWin->SetZOrder(NULL, WINDOW_ZORDER_FIRST); | |
| // erst mal testen, ob ich mich ueberhaupt bewegt habe | |
| // (das verhindert das Setzen des modified-Flags, wenn sich eigentlich gar nichts getan hat) | |
| TTableWindowData::value_type pData = m_pDragWin->GetData(); | |
| if ( ! (pData && pData->HasPosition() && (pData->GetPosition() == aDragWinPos))) | |
| { | |
| // die alten logischen Koordinaten | |
| Point ptOldPos = m_pDragWin->GetPosPixel() + Point(GetHScrollBar()->GetThumbPos(), GetVScrollBar()->GetThumbPos()); | |
| // neu positionieren | |
| m_pDragWin->SetPosPixel(aDragWinPos); | |
| TabWinMoved(m_pDragWin, ptOldPos); | |
| m_pDragWin->GrabFocus(); | |
| } | |
| m_pDragWin = NULL; | |
| SetPointer(Pointer(POINTER_ARROW)); | |
| } | |
| // else we handle the resizing | |
| else if( m_pSizingWin ) | |
| { | |
| SetPointer( Pointer() ); | |
| EndTracking(); | |
| // die alten physikalischen Koordinaten | |
| Size szOld = m_pSizingWin->GetSizePixel(); | |
| Point ptOld = m_pSizingWin->GetPosPixel(); | |
| Size aNewSize(CalcZoom(m_aSizingRect.GetSize().Width()),CalcZoom(m_aSizingRect.GetSize().Height())); | |
| m_pSizingWin->SetPosSizePixel( m_aSizingRect.TopLeft(), aNewSize ); | |
| TabWinSized(m_pSizingWin, ptOld, szOld); | |
| m_pSizingWin->Invalidate( m_aSizingRect ); | |
| m_pSizingWin = NULL; | |
| } | |
| } | |
| else if (rTEvt.IsTrackingCanceled()) | |
| { | |
| if (m_aDragScrollTimer.IsActive()) | |
| m_aDragScrollTimer.Stop(); | |
| EndTracking(); | |
| } | |
| else | |
| { | |
| if( m_pDragWin ) | |
| { | |
| m_ptPrevDraggingPos = rTEvt.GetMouseEvent().GetPosPixel(); | |
| // an Fenstergrenzen scrollen | |
| ScrollWhileDragging(); | |
| } | |
| if( m_pSizingWin ) | |
| { | |
| Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel(); | |
| m_aSizingRect = m_pSizingWin->getSizingRect(aMousePos,m_aOutputSize); | |
| Update(); | |
| ShowTracking( m_aSizingRect, SHOWTRACK_SMALL | SHOWTRACK_WINDOW ); | |
| } | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::ConnDoubleClicked( OTableConnection* /*pConnection*/ ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::MouseButtonDown( const MouseEvent& rEvt ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| GrabFocus(); | |
| Window::MouseButtonDown(rEvt); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::MouseButtonUp( const MouseEvent& rEvt ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| Window::MouseButtonUp(rEvt); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Wurde eine Connection ausgewaehlt? | |
| if( !m_vTableConnection.empty() ) | |
| { | |
| DeselectConn(GetSelectedConn()); | |
| ::std::vector<OTableConnection*>::iterator aIter = m_vTableConnection.begin(); | |
| ::std::vector<OTableConnection*>::iterator aEnd = m_vTableConnection.end(); | |
| for(;aIter != aEnd;++aIter) | |
| { | |
| if( (*aIter)->CheckHit(rEvt.GetPosPixel()) ) | |
| { | |
| SelectConn((*aIter)); | |
| // Doppelclick | |
| if( rEvt.GetClicks() == 2 ) | |
| ConnDoubleClicked( (*aIter) ); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::KeyInput( const KeyEvent& rEvt ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| sal_uInt16 nCode = rEvt.GetKeyCode().GetCode(); | |
| sal_Bool bShift = rEvt.GetKeyCode().IsShift(); | |
| sal_Bool bCtrl = rEvt.GetKeyCode().IsMod1(); | |
| if( !bCtrl && !bShift && (nCode==KEY_DELETE) ) | |
| { | |
| if (GetSelectedConn()) | |
| RemoveConnection( GetSelectedConn() ,sal_True); | |
| } | |
| else | |
| Window::KeyInput( rEvt ); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::DeselectConn(OTableConnection* pConn) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| if (!pConn || !pConn->IsSelected()) | |
| return; | |
| // die zugehoerigen Eitnraege in der ListBox des Tabellenfenster deselektieren | |
| OTableWindow* pWin = pConn->GetSourceWin(); | |
| if (pWin && pWin->GetListBox()) | |
| pWin->GetListBox()->SelectAll(sal_False); | |
| pWin = pConn->GetDestWin(); | |
| if (pWin && pWin->GetListBox()) | |
| pWin->GetListBox()->SelectAll(sal_False); | |
| pConn->Deselect(); | |
| m_pSelectedConn = NULL; | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::SelectConn(OTableConnection* pConn) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| DeselectConn(GetSelectedConn()); | |
| pConn->Select(); | |
| m_pSelectedConn = pConn; | |
| GrabFocus(); // has to be called here because a table window may still be focused | |
| // die betroffenene Eintraege in den Windows selektieren | |
| OTableWindow* pConnSource = pConn->GetSourceWin(); | |
| OTableWindow* pConnDest = pConn->GetDestWin(); | |
| if (pConnSource && pConnDest) | |
| { | |
| OTableWindowListBox* pSourceBox = pConnSource->GetListBox(); | |
| OTableWindowListBox* pDestBox = pConnDest->GetListBox(); | |
| if (pSourceBox && pDestBox) | |
| { | |
| pSourceBox->SelectAll(sal_False); | |
| pDestBox->SelectAll(sal_False); | |
| SvLBoxEntry* pFirstSourceVisible = pSourceBox->GetFirstEntryInView(); | |
| SvLBoxEntry* pFirstDestVisible = pDestBox->GetFirstEntryInView(); | |
| const ::std::vector<OConnectionLine*>* pLines = pConn->GetConnLineList(); | |
| ::std::vector<OConnectionLine*>::const_reverse_iterator aIter = pLines->rbegin(); | |
| for(;aIter != pLines->rend();++aIter) | |
| { | |
| if ((*aIter)->IsValid()) | |
| { | |
| SvLBoxEntry* pSourceEntry = pSourceBox->GetEntryFromText((*aIter)->GetData()->GetSourceFieldName()); | |
| if (pSourceEntry) | |
| { | |
| pSourceBox->Select(pSourceEntry, sal_True); | |
| pSourceBox->MakeVisible(pSourceEntry); | |
| } | |
| SvLBoxEntry* pDestEntry = pDestBox->GetEntryFromText((*aIter)->GetData()->GetDestFieldName()); | |
| if (pDestEntry) | |
| { | |
| pDestBox->Select(pDestEntry, sal_True); | |
| pDestBox->MakeVisible(pDestEntry); | |
| } | |
| } | |
| } | |
| if ((pFirstSourceVisible != pSourceBox->GetFirstEntryInView()) | |
| || (pFirstDestVisible != pDestBox->GetFirstEntryInView())) | |
| // es wurde gescrollt -> neu zeichnen | |
| Invalidate(INVALIDATE_NOCHILDREN); | |
| } | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::Paint( const Rectangle& rRect ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| DrawConnections( rRect ); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::InvalidateConnections() | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Die Joins zeichnen | |
| ::std::for_each(m_vTableConnection.begin(),m_vTableConnection.end(), | |
| ::std::mem_fun(& OTableConnection::InvalidateConnection)); | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::DrawConnections( const Rectangle& rRect ) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| ////////////////////////////////////////////////////////////////////// | |
| // Die Joins zeichnen | |
| ::std::for_each(m_vTableConnection.begin(),m_vTableConnection.end(),boost::bind( &OTableConnection::Draw, _1, boost::cref( rRect ))); | |
| // zum Schluss noch mal die selektierte ueber alle anderen drueber | |
| if (GetSelectedConn()) | |
| GetSelectedConn()->Draw( rRect ); | |
| } | |
| //------------------------------------------------------------------------------ | |
| ::std::vector<OTableConnection*>::const_iterator OJoinTableView::getTableConnections(const OTableWindow* _pFromWin) const | |
| { | |
| return ::std::find_if( m_vTableConnection.begin(), | |
| m_vTableConnection.end(), | |
| ::std::bind2nd(::std::mem_fun(&OTableConnection::isTableConnection),_pFromWin)); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Int32 OJoinTableView::getConnectionCount(const OTableWindow* _pFromWin) const | |
| { | |
| return ::std::count_if( m_vTableConnection.begin(), | |
| m_vTableConnection.end(), | |
| ::std::bind2nd(::std::mem_fun(&OTableConnection::isTableConnection),_pFromWin)); | |
| } | |
| //------------------------------------------------------------------------------ | |
| sal_Bool OJoinTableView::ExistsAConn(const OTableWindow* pFrom) const | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| return getTableConnections(pFrom) != m_vTableConnection.end(); | |
| } | |
| //------------------------------------------------------------------------ | |
| void OJoinTableView::ClearAll() | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| SetUpdateMode(sal_False); | |
| HideTabWins(); | |
| // und das selbe mit den Connections | |
| ::std::vector<OTableConnection*>::iterator aIter = m_vTableConnection.begin(); | |
| ::std::vector<OTableConnection*>::iterator aEnd = m_vTableConnection.end(); | |
| for(;aIter != aEnd;++aIter) | |
| RemoveConnection( *aIter ,sal_True); | |
| m_vTableConnection.clear(); | |
| m_pLastFocusTabWin = NULL; | |
| m_pSelectedConn = NULL; | |
| // scroll to the upper left | |
| ScrollPane(-GetScrollOffset().X(), sal_True, sal_True); | |
| ScrollPane(-GetScrollOffset().Y(), sal_False, sal_True); | |
| Invalidate(); | |
| } | |
| //------------------------------------------------------------------------ | |
| sal_Bool OJoinTableView::ScrollWhileDragging() | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| DBG_ASSERT(m_pDragWin != NULL, "OJoinTableView::ScrollWhileDragging darf nur waehrend Dragging eines Fensters aufgerufen werden !"); | |
| // den Timer schon mal killen | |
| if (m_aDragScrollTimer.IsActive()) | |
| m_aDragScrollTimer.Stop(); | |
| Point aDragWinPos = m_ptPrevDraggingPos - m_aDragOffset; | |
| Size aDragWinSize = m_pDragWin->GetSizePixel(); | |
| Point aLowerRight(aDragWinPos.X() + aDragWinSize.Width(), aDragWinPos.Y() + aDragWinSize.Height()); | |
| if (!m_bTrackingInitiallyMoved && (aDragWinPos == m_pDragWin->GetPosPixel())) | |
| return sal_True; | |
| // Darstellungsfehler vermeiden (wenn bei aktivem TrackingRect gescrollt wird) | |
| HideTracking(); | |
| sal_Bool bScrolling = sal_False; | |
| sal_Bool bNeedScrollTimer = sal_False; | |
| // An Fenstergrenzen scrollen | |
| // TODO : nur dann abfangen, wenn das Fenster komplett verschwinden wuerde (nicht, solange noch ein Pixel sichtbar ist) | |
| if( aDragWinPos.X() < 5 ) | |
| { | |
| bScrolling = ScrollPane( -LINE_SIZE, sal_True, sal_True ); | |
| if( !bScrolling && (aDragWinPos.X()<0) ) | |
| aDragWinPos.X() = 0; | |
| // brauche ich weiteres (timergesteuertes) Scrolling ? | |
| bNeedScrollTimer = bScrolling && (aDragWinPos.X() < 5); | |
| } | |
| if( aLowerRight.X() > m_aOutputSize.Width() - 5 ) | |
| { | |
| bScrolling = ScrollPane( LINE_SIZE, sal_True, sal_True ) ; | |
| if( !bScrolling && ( aLowerRight.X() > m_aOutputSize.Width() ) ) | |
| aDragWinPos.X() = m_aOutputSize.Width() - aDragWinSize.Width(); | |
| // brauche ich weiteres (timergesteuertes) Scrolling ? | |
| bNeedScrollTimer = bScrolling && (aLowerRight.X() > m_aOutputSize.Width() - 5); | |
| } | |
| if( aDragWinPos.Y() < 5 ) | |
| { | |
| bScrolling = ScrollPane( -LINE_SIZE, sal_False, sal_True ); | |
| if( !bScrolling && (aDragWinPos.Y()<0) ) | |
| aDragWinPos.Y() = 0; | |
| bNeedScrollTimer = bScrolling && (aDragWinPos.Y() < 5); | |
| } | |
| if( aLowerRight.Y() > m_aOutputSize.Height() - 5 ) | |
| { | |
| bScrolling = ScrollPane( LINE_SIZE, sal_False, sal_True ); | |
| if( !bScrolling && ( (aDragWinPos.Y() + aDragWinSize.Height()) > m_aOutputSize.Height() ) ) | |
| aDragWinPos.Y() = m_aOutputSize.Height() - aDragWinSize.Height(); | |
| bNeedScrollTimer = bScrolling && (aLowerRight.Y() > m_aOutputSize.Height() - 5); | |
| } | |
| // Timer neu setzen, wenn noch notwendig | |
| if (bNeedScrollTimer) | |
| { | |
| m_aDragScrollTimer.SetTimeout(100); | |
| m_aDragScrollTimer.Start(); | |
| } | |
| // das DraggingRect neu zeichnen | |
| m_aDragRect = Rectangle(m_ptPrevDraggingPos - m_aDragOffset, m_pDragWin->GetSizePixel()); | |
| Update(); | |
| ShowTracking( m_aDragRect, SHOWTRACK_SMALL | SHOWTRACK_WINDOW ); | |
| return bScrolling; | |
| } | |
| //------------------------------------------------------------------------ | |
| IMPL_LINK(OJoinTableView, OnDragScrollTimer, void*, EMPTYARG) | |
| { | |
| ScrollWhileDragging(); | |
| return 0L; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OJoinTableView::invalidateAndModify(SfxUndoAction *_pAction) | |
| { | |
| Invalidate(INVALIDATE_NOCHILDREN); | |
| m_pView->getController().addUndoActionAndInvalidate(_pAction); | |
| } | |
| //------------------------------------------------------------------------ | |
| void OJoinTableView::TabWinMoved(OTableWindow* ptWhich, const Point& ptOldPosition) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| Point ptThumbPos(GetHScrollBar()->GetThumbPos(), GetVScrollBar()->GetThumbPos()); | |
| ptWhich->GetData()->SetPosition(ptWhich->GetPosPixel() + ptThumbPos); | |
| invalidateAndModify(new OJoinMoveTabWinUndoAct(this, ptOldPosition, ptWhich)); | |
| } | |
| //------------------------------------------------------------------------ | |
| void OJoinTableView::TabWinSized(OTableWindow* ptWhich, const Point& ptOldPosition, const Size& szOldSize) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| ptWhich->GetData()->SetSize(ptWhich->GetSizePixel()); | |
| ptWhich->GetData()->SetPosition(ptWhich->GetPosPixel()); | |
| invalidateAndModify(new OJoinSizeTabWinUndoAct(this, ptOldPosition, szOldSize, ptWhich)); | |
| } | |
| //------------------------------------------------------------------------------ | |
| sal_Bool OJoinTableView::IsAddAllowed() | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| // nicht wenn Db readonly | |
| if (m_pView->getController().isReadOnly()) | |
| return sal_False; | |
| try | |
| { | |
| Reference< XConnection> xConnection = m_pView->getController().getConnection(); | |
| if(!xConnection.is()) | |
| return sal_False; | |
| // nicht wenn schon zuviele Tabellen | |
| Reference < XDatabaseMetaData > xMetaData( xConnection->getMetaData() ); | |
| sal_Int32 nMax = xMetaData.is() ? xMetaData->getMaxTablesInSelect() : 0; | |
| if (nMax && nMax <= (sal_Int32)m_aTableMap.size()) | |
| return sal_False; | |
| } | |
| catch(SQLException&) | |
| { | |
| return sal_False; | |
| } | |
| // nicht wenn keine Joins moeglich | |
| // if (!GetDatabase()->IsCapable(SDB_CAP_JOIN) && nMax <= GetTabWinCount()) | |
| // return sal_False; | |
| return sal_True; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OJoinTableView::executePopup(const Point& _aPos,OTableConnection* _pSelConnection) | |
| { | |
| PopupMenu aContextMenu( ModuleRes( RID_MENU_JOINVIEW_CONNECTION ) ); | |
| switch (aContextMenu.Execute(this, _aPos)) | |
| { | |
| case SID_DELETE: | |
| RemoveConnection( _pSelConnection ,sal_True); | |
| break; | |
| case ID_QUERY_EDIT_JOINCONNECTION: | |
| ConnDoubleClicked( _pSelConnection ); // is the same as double clicked | |
| break; | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::Command(const CommandEvent& rEvt) | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| sal_Bool bHandled = sal_False; | |
| switch (rEvt.GetCommand()) | |
| { | |
| case COMMAND_CONTEXTMENU: | |
| { | |
| if( m_vTableConnection.empty() ) | |
| return; | |
| OTableConnection* pSelConnection = GetSelectedConn(); | |
| // when it wasn't a mouse event use the selected connection | |
| if (!rEvt.IsMouseEvent()) | |
| { | |
| if( pSelConnection ) | |
| { | |
| const ::std::vector<OConnectionLine*>* pLines = pSelConnection->GetConnLineList(); | |
| ::std::vector<OConnectionLine*>::const_iterator aIter = ::std::find_if(pLines->begin(),pLines->end(),::std::mem_fun(&OConnectionLine::IsValid)); | |
| if( aIter != pLines->end() ) | |
| executePopup((*aIter)->getMidPoint(),pSelConnection); | |
| } | |
| } | |
| else | |
| { | |
| DeselectConn(pSelConnection); | |
| const Point& aMousePos = rEvt.GetMousePosPixel(); | |
| ::std::vector<OTableConnection*>::iterator aIter = m_vTableConnection.begin(); | |
| ::std::vector<OTableConnection*>::iterator aEnd = m_vTableConnection.end(); | |
| for(;aIter != aEnd;++aIter) | |
| { | |
| if( (*aIter)->CheckHit(aMousePos) ) | |
| { | |
| SelectConn(*aIter); | |
| if(!getDesignView()->getController().isReadOnly() && getDesignView()->getController().isConnected()) | |
| executePopup(rEvt.GetMousePosPixel(),*aIter); | |
| break; | |
| } | |
| } | |
| } | |
| bHandled = sal_True; | |
| } | |
| } | |
| if (!bHandled) | |
| Window::Command(rEvt); | |
| } | |
| //------------------------------------------------------------------------------ | |
| OTableConnection* OJoinTableView::GetTabConn(const OTableWindow* pLhs,const OTableWindow* pRhs,bool _bSupressCrossOrNaturalJoin,const OTableConnection* _rpFirstAfter) const | |
| { | |
| OTableConnection* pConn = NULL; | |
| DBG_ASSERT(pRhs || pLhs, "OJoinTableView::GetTabConn : invalid args !"); | |
| // only one NULL-arg allowed | |
| if ((!pLhs || pLhs->ExistsAConn()) && (!pRhs || pRhs->ExistsAConn())) | |
| { | |
| sal_Bool bFoundStart = _rpFirstAfter ? sal_False : sal_True; | |
| ::std::vector<OTableConnection*>::const_iterator aIter = m_vTableConnection.begin(); | |
| ::std::vector<OTableConnection*>::const_iterator aEnd = m_vTableConnection.end(); | |
| for(;aIter != aEnd;++aIter) | |
| { | |
| OTableConnection* pData = *aIter; | |
| if ( ( (pData->GetSourceWin() == pLhs) | |
| && ( (pData->GetDestWin() == pRhs) | |
| || (NULL == pRhs) | |
| ) | |
| ) | |
| || ( (pData->GetSourceWin() == pRhs) | |
| && ( (pData->GetDestWin() == pLhs) | |
| || (NULL == pLhs) | |
| ) | |
| ) | |
| ) | |
| { | |
| if ( _bSupressCrossOrNaturalJoin ) | |
| { | |
| if ( supressCrossNaturalJoin(pData->GetData()) ) | |
| continue; | |
| } | |
| if (bFoundStart) | |
| { | |
| pConn = pData; | |
| break; | |
| } | |
| if (!pConn) | |
| // used as fallback : if there is no conn after _rpFirstAfter the first conn between the two tables | |
| // will be used | |
| pConn = pData; | |
| if (pData == _rpFirstAfter) | |
| bFoundStart = sal_True; | |
| } | |
| } | |
| } | |
| return pConn; | |
| } | |
| //------------------------------------------------------------------------------ | |
| long OJoinTableView::PreNotify(NotifyEvent& rNEvt) | |
| { | |
| sal_Bool bHandled = sal_False; | |
| switch (rNEvt.GetType()) | |
| { | |
| case EVENT_COMMAND: | |
| { | |
| const CommandEvent* pCommand = rNEvt.GetCommandEvent(); | |
| if (pCommand->GetCommand() == COMMAND_WHEEL) | |
| { | |
| const CommandWheelData* pData = rNEvt.GetCommandEvent()->GetWheelData(); | |
| if (pData->GetMode() == COMMAND_WHEEL_SCROLL) | |
| { | |
| if (pData->GetDelta() > 0) | |
| ScrollPane(-10 * pData->GetScrollLines(), pData->IsHorz(), sal_True); | |
| else | |
| ScrollPane(10 * pData->GetScrollLines(), pData->IsHorz(), sal_True); | |
| bHandled = sal_True; | |
| } | |
| } | |
| } | |
| break; | |
| case EVENT_KEYINPUT: | |
| { | |
| if (m_aTableMap.empty()) | |
| // no tab wins -> no conns -> no traveling | |
| break; | |
| const KeyEvent* pKeyEvent = rNEvt.GetKeyEvent(); | |
| if (!pKeyEvent->GetKeyCode().IsMod1()) | |
| { | |
| switch (pKeyEvent->GetKeyCode().GetCode()) | |
| { | |
| case KEY_TAB: | |
| { | |
| if (!HasChildPathFocus()) | |
| break; | |
| sal_Bool bForward = !pKeyEvent->GetKeyCode().IsShift(); | |
| // is there an active tab win ? | |
| OTableWindowMapIterator aIter = m_aTableMap.begin(); | |
| OTableWindowMapIterator aEnd = m_aTableMap.end(); | |
| for(;aIter != aEnd;++aIter) | |
| if (aIter->second && aIter->second->HasChildPathFocus()) | |
| break; | |
| OTableWindow* pNextWin = NULL; | |
| OTableConnection* pNextConn = NULL; | |
| if (aIter != m_aTableMap.end()) | |
| { // there is a currently active tab win | |
| // check if there is an "overflow" and we should select a conn instead of a win | |
| if (!m_vTableConnection.empty()) | |
| { | |
| if ((aIter->second == m_aTableMap.rbegin()->second) && bForward) | |
| // the last win is active and we're travelling forward -> select the first conn | |
| pNextConn = *m_vTableConnection.begin(); | |
| if ((aIter == m_aTableMap.begin()) && !bForward) | |
| // the first win is active an we're traveling backward -> select the last conn | |
| pNextConn = *m_vTableConnection.rbegin(); | |
| } | |
| if (!pNextConn) | |
| { | |
| // no conn for any reason -> select the next or previous tab win | |
| if(bForward) | |
| { | |
| if( aIter->second == m_aTableMap.rbegin()->second) | |
| pNextWin = m_aTableMap.begin()->second; | |
| else | |
| { | |
| ++aIter; | |
| pNextWin = aIter->second; | |
| } | |
| } | |
| else | |
| { | |
| if (aIter == m_aTableMap.begin()) | |
| pNextWin = m_aTableMap.rbegin()->second; | |
| else | |
| { | |
| --aIter; | |
| pNextWin = aIter->second; | |
| } | |
| } | |
| } | |
| } | |
| else | |
| { // no active tab win -> travel the connections | |
| // find the currently selected conn within the conn list | |
| sal_Int32 i(0); | |
| for ( ::std::vector<OTableConnection*>::iterator connectionIter = m_vTableConnection.begin(); | |
| connectionIter != m_vTableConnection.end(); | |
| ++connectionIter, ++i | |
| ) | |
| { | |
| if ( (*connectionIter) == GetSelectedConn() ) | |
| break; | |
| } | |
| if (i == sal_Int32(m_vTableConnection.size() - 1) && bForward) | |
| // the last conn is active and we're travelling forward -> select the first win | |
| pNextWin = m_aTableMap.begin()->second; | |
| if ((i == 0) && !bForward && !m_aTableMap.empty()) | |
| // the first conn is active and we're travelling backward -> select the last win | |
| pNextWin = m_aTableMap.rbegin()->second; | |
| if (pNextWin) | |
| DeselectConn(GetSelectedConn()); | |
| else | |
| // no win for any reason -> select the next or previous conn | |
| if (i < (sal_Int32)m_vTableConnection.size()) | |
| // there is a currently active conn | |
| pNextConn = m_vTableConnection[(i + (bForward ? 1 : m_vTableConnection.size() - 1)) % m_vTableConnection.size()]; | |
| else | |
| { // no tab win selected, no conn selected | |
| if (!m_vTableConnection.empty()) | |
| pNextConn = m_vTableConnection[bForward ? 0 : m_vTableConnection.size() - 1]; | |
| else if (!m_aTableMap.empty()) | |
| { | |
| if(bForward) | |
| pNextWin = m_aTableMap.begin()->second; | |
| else | |
| pNextWin = m_aTableMap.rbegin()->second; | |
| } | |
| } | |
| } | |
| // now select the object | |
| if (pNextWin) | |
| { | |
| if (pNextWin->GetListBox()) | |
| pNextWin->GetListBox()->GrabFocus(); | |
| else | |
| pNextWin->GrabFocus(); | |
| EnsureVisible(pNextWin); | |
| } | |
| else if (pNextConn) | |
| { | |
| GrabFocus(); | |
| // necessary : a conn may be selected even if a tab win has the focus, in this case | |
| // the next travel would select the same conn again if we would not reset te focus ... | |
| SelectConn(pNextConn); | |
| } | |
| } | |
| break; | |
| case KEY_RETURN: | |
| { | |
| if (!pKeyEvent->GetKeyCode().IsShift() && GetSelectedConn() && HasFocus()) | |
| ConnDoubleClicked(GetSelectedConn()); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| break; | |
| case EVENT_GETFOCUS: | |
| { | |
| if (m_aTableMap.empty()) | |
| // no tab wins -> no conns -> no focus change | |
| break; | |
| Window* pSource = rNEvt.GetWindow(); | |
| if (pSource) | |
| { | |
| Window* pSearchFor = NULL; | |
| if (pSource->GetParent() == this) | |
| // it may be one of the tab wins | |
| pSearchFor = pSource; | |
| else if (pSource->GetParent() && (pSource->GetParent()->GetParent() == this)) | |
| // it may be one of th list boxes of one of the tab wins | |
| pSearchFor = pSource->GetParent(); | |
| if (pSearchFor) | |
| { | |
| OTableWindowMapIterator aIter = m_aTableMap.begin(); | |
| OTableWindowMapIterator aEnd = m_aTableMap.end(); | |
| for(;aIter != aEnd;++aIter) | |
| { | |
| if (aIter->second == pSearchFor) | |
| { | |
| m_pLastFocusTabWin = aIter->second; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| break; | |
| } | |
| if (!bHandled) | |
| return Window::PreNotify(rNEvt); | |
| return 1L; | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::GrabTabWinFocus() | |
| { | |
| if (m_pLastFocusTabWin && m_pLastFocusTabWin->IsVisible()) | |
| { | |
| if (m_pLastFocusTabWin->GetListBox()) | |
| m_pLastFocusTabWin->GetListBox()->GrabFocus(); | |
| else | |
| m_pLastFocusTabWin->GrabFocus(); | |
| } | |
| else if (!m_aTableMap.empty() && m_aTableMap.begin()->second && m_aTableMap.begin()->second->IsVisible()) | |
| { | |
| OTableWindow* pFirstWin = m_aTableMap.begin()->second; | |
| if (pFirstWin->GetListBox()) | |
| pFirstWin->GetListBox()->GrabFocus(); | |
| else | |
| pFirstWin->GrabFocus(); | |
| } | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OJoinTableView::StateChanged( StateChangedType nType ) | |
| { | |
| Window::StateChanged( nType ); | |
| if ( nType == STATE_CHANGE_ZOOM ) | |
| { | |
| const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); | |
| Font aFont = rStyleSettings.GetGroupFont(); | |
| if ( IsControlFont() ) | |
| aFont.Merge( GetControlFont() ); | |
| SetZoomedPointFont( aFont ); | |
| OTableWindowMapIterator aIter = m_aTableMap.begin(); | |
| OTableWindowMapIterator aEnd = m_aTableMap.end(); | |
| for(;aIter != aEnd;++aIter) | |
| { | |
| aIter->second->SetZoom(GetZoom()); | |
| Size aSize(CalcZoom(aIter->second->GetSizePixel().Width()),CalcZoom(aIter->second->GetSizePixel().Height())); | |
| aIter->second->SetSizePixel(aSize); | |
| } | |
| Resize(); | |
| } | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::HideTabWins() | |
| { | |
| DBG_CHKTHIS(OJoinTableView,NULL); | |
| SetUpdateMode(sal_False); | |
| OTableWindowMap* pTabWins = GetTabWinMap(); | |
| if ( pTabWins ) | |
| { | |
| // working on a copy because the real list will be cleared in inner calls | |
| OTableWindowMap aCopy(*pTabWins); | |
| OTableWindowMap::iterator aIter = aCopy.begin(); | |
| OTableWindowMap::iterator aEnd = aCopy.end(); | |
| for(;aIter != aEnd;++aIter) | |
| RemoveTabWin(aIter->second); | |
| } | |
| m_pView->getController().setModified(sal_True); | |
| SetUpdateMode(sal_True); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Int8 OJoinTableView::AcceptDrop( const AcceptDropEvent& /*_rEvt*/ ) | |
| { | |
| return DND_ACTION_NONE; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| sal_Int8 OJoinTableView::ExecuteDrop( const ExecuteDropEvent& /*_rEvt*/ ) | |
| { | |
| return DND_ACTION_NONE; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OJoinTableView::dragFinished( ) | |
| { | |
| } | |
| //------------------------------------------------------------------------------ | |
| void OJoinTableView::StartDrag( sal_Int8 /*nAction*/, const Point& /*rPosPixel*/ ) | |
| { | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OJoinTableView::clearLayoutInformation() | |
| { | |
| m_pLastFocusTabWin = NULL; | |
| m_pSelectedConn = NULL; | |
| ////////////////////////////////////////////////////////////////////// | |
| // Listen loeschen | |
| OTableWindowMapIterator aIter = m_aTableMap.begin(); | |
| OTableWindowMapIterator aEnd = m_aTableMap.end(); | |
| for(;aIter != aEnd;++aIter) | |
| { | |
| if ( aIter->second ) | |
| aIter->second->clearListBox(); | |
| ::std::auto_ptr<Window> aTemp(aIter->second); | |
| aIter->second = NULL; | |
| } | |
| m_aTableMap.clear(); | |
| ::std::vector<OTableConnection*>::const_iterator aIter2 = m_vTableConnection.begin(); | |
| ::std::vector<OTableConnection*>::const_iterator aEnd2 = m_vTableConnection.end(); | |
| for(;aIter2 != aEnd2;++aIter2) | |
| delete *aIter2; | |
| m_vTableConnection.clear(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OJoinTableView::lookForUiActivities() | |
| { | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OJoinTableView::LoseFocus() | |
| { | |
| DeselectConn(GetSelectedConn()); | |
| Window::LoseFocus(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OJoinTableView::GetFocus() | |
| { | |
| Window::GetFocus(); | |
| if ( !m_aTableMap.empty() && !GetSelectedConn() ) | |
| GrabTabWinFocus(); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| Reference< XAccessible > OJoinTableView::CreateAccessible() | |
| { | |
| m_pAccessible = new OJoinDesignViewAccess(this); | |
| return m_pAccessible; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OJoinTableView::modified() | |
| { | |
| OJoinController& rController = m_pView->getController(); | |
| rController.setModified( sal_True ); | |
| rController.InvalidateFeature(ID_BROWSER_ADDTABLE); | |
| rController.InvalidateFeature(SID_RELATION_ADD_RELATION); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OJoinTableView::addConnection(OTableConnection* _pConnection,sal_Bool _bAddData) | |
| { | |
| if ( _bAddData ) | |
| { | |
| #if OSL_DEBUG_LEVEL > 0 | |
| TTableConnectionData* pTabConnDataList = m_pView->getController().getTableConnectionData(); | |
| OSL_ENSURE( ::std::find(pTabConnDataList->begin(),pTabConnDataList->end(),_pConnection->GetData()) == pTabConnDataList->end(),"Data already in vector!"); | |
| #endif | |
| m_pView->getController().getTableConnectionData()->push_back(_pConnection->GetData()); | |
| } | |
| m_vTableConnection.push_back(_pConnection); | |
| _pConnection->RecalcLines(); | |
| _pConnection->InvalidateConnection(); | |
| modified(); | |
| if ( m_pAccessible ) | |
| m_pAccessible->notifyAccessibleEvent( AccessibleEventId::CHILD, | |
| Any(), | |
| makeAny(_pConnection->GetAccessible())); | |
| } | |
| // ----------------------------------------------------------------------------- | |
| bool OJoinTableView::allowQueries() const | |
| { | |
| return true; | |
| } | |
| // ----------------------------------------------------------------------------- | |
| void OJoinTableView::onNoColumns_throw() | |
| { | |
| OSL_ENSURE( false, "OTableWindow::onNoColumns_throw: cannot really handle this!" ); | |
| throw SQLException(); | |
| } | |
| //------------------------------------------------------------------------------ | |
| bool OJoinTableView::supressCrossNaturalJoin(const TTableConnectionData::value_type& ) const | |
| { | |
| return false; | |
| } |