| /************************************************************** |
| * |
| * 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_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 neccessary |
| 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(); |
| // neccessary : 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; |
| } |