| /************************************************************** | |
| * | |
| * 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_toolkit.hxx" | |
| #include <com/sun/star/beans/XPropertySet.hpp> | |
| #include <com/sun/star/awt/XVclContainerPeer.hpp> | |
| #include <toolkit/controls/stdtabcontroller.hxx> | |
| #include <toolkit/controls/stdtabcontrollermodel.hxx> | |
| #include <toolkit/awt/vclxwindow.hxx> | |
| #include <toolkit/helper/macros.hxx> | |
| #include <cppuhelper/typeprovider.hxx> | |
| #include <rtl/memory.h> | |
| #include <rtl/uuid.h> | |
| #include <tools/debug.hxx> | |
| #include <vcl/window.hxx> | |
| #include <comphelper/sequence.hxx> | |
| using namespace ::com::sun::star; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::awt; | |
| using namespace ::com::sun::star::lang; | |
| using namespace ::com::sun::star::beans; | |
| // ---------------------------------------------------- | |
| // class StdTabController | |
| // ---------------------------------------------------- | |
| StdTabController::StdTabController() | |
| { | |
| } | |
| StdTabController::~StdTabController() | |
| { | |
| } | |
| sal_Bool StdTabController::ImplCreateComponentSequence( | |
| Sequence< Reference< XControl > >& rControls, | |
| const Sequence< Reference< XControlModel > >& rModels, | |
| Sequence< Reference< XWindow > >& rComponents, | |
| Sequence< Any>* pTabStops, | |
| sal_Bool bPeerComponent ) const | |
| { | |
| sal_Bool bOK = sal_True; | |
| // nur die wirklich geforderten Controls | |
| sal_Int32 nModels = rModels.getLength(); | |
| if (nModels != rControls.getLength()) | |
| { | |
| Sequence< Reference< XControl > > aSeq( nModels ); | |
| const Reference< XControlModel >* pModels = rModels.getConstArray(); | |
| Reference< XControl > xCurrentControl; | |
| sal_Int32 nRealControls = 0; | |
| for (sal_Int32 n = 0; n < nModels; ++n, ++pModels) | |
| { | |
| xCurrentControl = FindControl(rControls, *pModels); | |
| if (xCurrentControl.is()) | |
| aSeq.getArray()[nRealControls++] = xCurrentControl; | |
| } | |
| aSeq.realloc(nRealControls); | |
| rControls = aSeq; | |
| } | |
| #ifdef DBG_UTIL | |
| DBG_ASSERT( rControls.getLength() <= rModels.getLength(), "StdTabController:ImplCreateComponentSequence: inconsistence!" ); | |
| // there may be less controls than models, but never more controls than models | |
| #endif | |
| const Reference< XControl > * pControls = rControls.getConstArray(); | |
| sal_uInt32 nCtrls = rControls.getLength(); | |
| rComponents.realloc( nCtrls ); | |
| Reference< XWindow > * pComps = rComponents.getArray(); | |
| Any* pTabs = NULL; | |
| if ( pTabStops ) | |
| { | |
| *pTabStops = Sequence< Any>( nCtrls ); | |
| pTabs = pTabStops->getArray(); | |
| } | |
| for ( sal_uInt32 n = 0; bOK && ( n < nCtrls ); n++ ) | |
| { | |
| // Zum Model passendes Control suchen | |
| Reference< XControl > xCtrl(pControls[n]); | |
| if ( xCtrl.is() ) | |
| { | |
| if (bPeerComponent) | |
| pComps[n] = Reference< XWindow > (xCtrl->getPeer(), UNO_QUERY); | |
| else | |
| pComps[n] = Reference< XWindow > (xCtrl, UNO_QUERY); | |
| // TabStop-Property | |
| if ( pTabs ) | |
| { | |
| // opt: String fuer TabStop als Konstante | |
| static const ::rtl::OUString aTabStopName( ::rtl::OUString::createFromAscii( "Tabstop" ) ); | |
| Reference< XPropertySet > xPSet( xCtrl->getModel(), UNO_QUERY ); | |
| Reference< XPropertySetInfo > xInfo = xPSet->getPropertySetInfo(); | |
| if( xInfo->hasPropertyByName( aTabStopName ) ) | |
| *pTabs++ = xPSet->getPropertyValue( aTabStopName ); | |
| else | |
| ++pTabs; | |
| } | |
| } | |
| else | |
| { | |
| DBG_TRACE( "ImplCreateComponentSequence: Control not found" ); | |
| bOK = sal_False; | |
| } | |
| } | |
| return bOK; | |
| } | |
| void StdTabController::ImplActivateControl( sal_Bool bFirst ) const | |
| { | |
| // HACK wegen #53688#, muss auf ein Interface abgebildet werden, wenn Controls Remote liegen koennen. | |
| Reference< XTabController > xTabController(const_cast< ::cppu::OWeakObject* >(static_cast< const ::cppu::OWeakObject* >(this)), UNO_QUERY); | |
| Sequence< Reference< XControl > > aCtrls = xTabController->getControls(); | |
| const Reference< XControl > * pControls = aCtrls.getConstArray(); | |
| sal_uInt32 nCount = aCtrls.getLength(); | |
| for ( sal_uInt32 n = bFirst ? 0 : nCount; bFirst ? ( n < nCount ) : n; ) | |
| { | |
| sal_uInt32 nCtrl = bFirst ? n++ : --n; | |
| DBG_ASSERT( pControls[nCtrl].is(), "Control nicht im Container!" ); | |
| if ( pControls[nCtrl].is() ) | |
| { | |
| Reference< XWindowPeer > xCP = pControls[nCtrl]->getPeer(); | |
| if ( xCP.is() ) | |
| { | |
| VCLXWindow* pC = VCLXWindow::GetImplementation( xCP ); | |
| if ( pC && pC->GetWindow() && ( pC->GetWindow()->GetStyle() & WB_TABSTOP ) ) | |
| { | |
| pC->GetWindow()->GrabFocus(); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| // XInterface | |
| Any StdTabController::queryAggregation( const Type & rType ) | |
| { | |
| Any aRet = ::cppu::queryInterface( rType, | |
| SAL_STATIC_CAST( XTabController*, this ), | |
| SAL_STATIC_CAST( XServiceInfo*, this ), | |
| SAL_STATIC_CAST( XTypeProvider*, this ) ); | |
| return (aRet.hasValue() ? aRet : OWeakAggObject::queryAggregation( rType )); | |
| } | |
| // XTypeProvider | |
| IMPL_XTYPEPROVIDER_START( StdTabController ) | |
| getCppuType( ( Reference< XTabController>* ) NULL ), | |
| getCppuType( ( Reference< XServiceInfo>* ) NULL ) | |
| IMPL_XTYPEPROVIDER_END | |
| void StdTabController::setModel( const Reference< XTabControllerModel >& Model ) | |
| { | |
| ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); | |
| mxModel = Model; | |
| } | |
| Reference< XTabControllerModel > StdTabController::getModel( ) | |
| { | |
| ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); | |
| return mxModel; | |
| } | |
| void StdTabController::setContainer( const Reference< XControlContainer >& Container ) | |
| { | |
| ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); | |
| mxControlContainer = Container; | |
| } | |
| Reference< XControlContainer > StdTabController::getContainer( ) | |
| { | |
| ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); | |
| return mxControlContainer; | |
| } | |
| Sequence< Reference< XControl > > StdTabController::getControls( ) | |
| { | |
| ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); | |
| Sequence< Reference< XControl > > aSeq; | |
| if ( mxControlContainer.is() ) | |
| { | |
| Sequence< Reference< XControlModel > > aModels = mxModel->getControlModels(); | |
| const Reference< XControlModel > * pModels = aModels.getConstArray(); | |
| Sequence< Reference< XControl > > xCtrls = mxControlContainer->getControls(); | |
| sal_uInt32 nCtrls = aModels.getLength(); | |
| aSeq = Sequence< Reference< XControl > >( nCtrls ); | |
| for ( sal_uInt32 n = 0; n < nCtrls; n++ ) | |
| { | |
| Reference< XControlModel > xCtrlModel = pModels[n]; | |
| // Zum Model passendes Control suchen | |
| Reference< XControl > xCtrl = FindControl( xCtrls, xCtrlModel ); | |
| aSeq.getArray()[n] = xCtrl; | |
| } | |
| } | |
| return aSeq; | |
| } | |
| void StdTabController::autoTabOrder( ) | |
| { | |
| ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); | |
| DBG_ASSERT( mxControlContainer.is(), "autoTabOrder: No ControlContainer!" ); | |
| if ( !mxControlContainer.is() ) | |
| return; | |
| Sequence< Reference< XControlModel > > aSeq = mxModel->getControlModels(); | |
| Sequence< Reference< XWindow > > aCompSeq; | |
| // vieleicht erhalte ich hier einen TabController, | |
| // der schneller die Liste meiner Controls ermittelt | |
| Reference< XTabController > xTabController(static_cast< ::cppu::OWeakObject* >(this), UNO_QUERY); | |
| Sequence< Reference< XControl > > aControls = xTabController->getControls(); | |
| // #58317# Es sind ggf. noch nicht alle Controls fuer die Models im Container, | |
| // dann kommt spaeter nochmal ein autoTabOrder... | |
| if( !ImplCreateComponentSequence( aControls, aSeq, aCompSeq, NULL, sal_False ) ) | |
| return; | |
| sal_uInt32 nCtrls = aCompSeq.getLength(); | |
| Reference< XWindow > * pComponents = aCompSeq.getArray(); | |
| ComponentEntryList aCtrls; | |
| sal_uInt32 n; | |
| for ( n = 0; n < nCtrls; n++ ) | |
| { | |
| XWindow* pC = (XWindow*)pComponents[n].get(); | |
| ComponentEntry* pE = new ComponentEntry; | |
| pE->pComponent = pC; | |
| awt::Rectangle aPosSize = pC->getPosSize(); | |
| pE->aPos.X() = aPosSize.X; | |
| pE->aPos.Y() = aPosSize.Y; | |
| sal_uInt16 nPos; | |
| for ( nPos = 0; nPos < aCtrls.Count(); nPos++ ) | |
| { | |
| ComponentEntry* pEntry = aCtrls.GetObject( nPos ); | |
| if ( pEntry->aPos.Y() >= pE->aPos.Y() ) | |
| { | |
| while ( pEntry && ( pEntry->aPos.Y() == pE->aPos.Y() ) | |
| && ( pEntry->aPos.X() < pE->aPos.X() ) ) | |
| { | |
| pEntry = aCtrls.GetObject( ++nPos ); | |
| } | |
| break; | |
| } | |
| } | |
| aCtrls.Insert( pE, nPos ); | |
| } | |
| Sequence< Reference< XControlModel > > aNewSeq( nCtrls ); | |
| for ( n = 0; n < nCtrls; n++ ) | |
| { | |
| ComponentEntry* pE = aCtrls.GetObject( n ); | |
| Reference< XControl > xUC( pE->pComponent, UNO_QUERY ); | |
| aNewSeq.getArray()[n] = xUC->getModel(); | |
| delete pE; | |
| } | |
| aCtrls.Clear(); | |
| mxModel->setControlModels( aNewSeq ); | |
| } | |
| void StdTabController::activateTabOrder( ) | |
| { | |
| ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); | |
| // Am Container die Tab-Reihenfolge aktivieren... | |
| Reference< XControl > xC( mxControlContainer, UNO_QUERY ); | |
| Reference< XVclContainerPeer > xVclContainerPeer; | |
| if ( xC.is() ) | |
| xVclContainerPeer = xVclContainerPeer.query( xC->getPeer() ); | |
| if ( !xC.is() || !xVclContainerPeer.is() ) | |
| return; | |
| // vieleicht erhalte ich hier einen TabController, | |
| // der schneller die Liste meiner Controls ermittelt | |
| Reference< XTabController > xTabController(static_cast< ::cppu::OWeakObject* >(this), UNO_QUERY); | |
| // Flache Liste besorgen... | |
| Sequence< Reference< XControlModel > > aModels = mxModel->getControlModels(); | |
| Sequence< Reference< XWindow > > aCompSeq; | |
| Sequence< Any> aTabSeq; | |
| // DG: Aus Optimierungsgruenden werden die Controls mittels getControls() geholt, | |
| // dieses hoert sich zwar wiedersinning an, fuehrt aber im konkreten Fall (Forms) zu sichtbaren | |
| // Geschwindigkeitsvorteilen | |
| Sequence< Reference< XControl > > aControls = xTabController->getControls(); | |
| // #58317# Es sind ggf. noch nicht alle Controls fuer die Models im Container, | |
| // dann kommt spaeter nochmal ein activateTabOrder... | |
| if( !ImplCreateComponentSequence( aControls, aModels, aCompSeq, &aTabSeq, sal_True ) ) | |
| return; | |
| xVclContainerPeer->setTabOrder( aCompSeq, aTabSeq, mxModel->getGroupControl() ); | |
| ::rtl::OUString aName; | |
| Sequence< Reference< XControlModel > > aThisGroupModels; | |
| Sequence< Reference< XWindow > > aControlComponents; | |
| sal_uInt32 nGroups = mxModel->getGroupCount(); | |
| for ( sal_uInt32 nG = 0; nG < nGroups; nG++ ) | |
| { | |
| mxModel->getGroup( nG, aThisGroupModels, aName ); | |
| aControls = xTabController->getControls(); | |
| // ImplCreateComponentSequence has a really strange semantics regarding it's first parameter: | |
| // upon method entry, it expects a super set of the controls which it returns | |
| // this means we need to completely fill this sequence with all available controls before | |
| // calling into ImplCreateComponentSequence | |
| aControlComponents.realloc( 0 ); | |
| ImplCreateComponentSequence( aControls, aThisGroupModels, aControlComponents, NULL, sal_True ); | |
| xVclContainerPeer->setGroup( aControlComponents ); | |
| } | |
| } | |
| void StdTabController::activateFirst( ) | |
| { | |
| ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); | |
| ImplActivateControl( sal_True ); | |
| } | |
| void StdTabController::activateLast( ) | |
| { | |
| ::osl::Guard< ::osl::Mutex > aGuard( GetMutex() ); | |
| ImplActivateControl( sal_False ); | |
| } | |
| Reference< XControl > StdTabController::FindControl( Sequence< Reference< XControl > >& rCtrls, | |
| const Reference< XControlModel > & rxCtrlModel ) | |
| { | |
| /* | |
| // MT: Funktioniert nicht mehr, weil ich nicht mehr bei mir angemeldet bin, | |
| // weil DG das abfaengt. | |
| // #54677# Beim Laden eines HTML-Dokuments wird nach jedem Control ein | |
| // activateTabOrder gerufen und jede Menge Zeit in dieser Methode verbraten. | |
| // Die Anzahl dieser Schleifendurchlaufe steigt quadratisch, also versuchen | |
| // das Control direkt vom Model zu erhalten. | |
| // => Wenn genau ein Control als PropertyChangeListener angemeldet ist, | |
| // dann muss das auch das richtige sein. | |
| UnoControlModel* pUnoCtrlModel = UnoControlModel::GetImplementation( rxCtrlModel ); | |
| if ( pUnoCtrlModel ) | |
| { | |
| ListenerIterator aIt( pUnoCtrlModel->maPropertiesListeners ); | |
| while( aIt.hasMoreElements() ) | |
| { | |
| XEventListener* pL = aIt.next(); | |
| Reference< XControl > xC( pL, UNO_QUERY ); | |
| if ( xC.is() ) | |
| { | |
| if( xC->getContext() == mxControlContainer ) | |
| { | |
| xCtrl = xC; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| if ( !xCtrl.is() && rxCtrlModel.is()) | |
| */ | |
| DBG_ASSERT( rxCtrlModel.is(), "ImplFindControl - welches ?!" ); | |
| const Reference< XControl > * pCtrls = rCtrls.getConstArray(); | |
| sal_Int32 nCtrls = rCtrls.getLength(); | |
| for ( sal_Int32 n = 0; n < nCtrls; n++ ) | |
| { | |
| Reference< XControlModel > xModel(pCtrls[n].is() ? pCtrls[n]->getModel() : Reference< XControlModel > ()); | |
| if ( (XControlModel*)xModel.get() == (XControlModel*)rxCtrlModel.get() ) | |
| { | |
| Reference< XControl > xCtrl( pCtrls[n] ); | |
| ::comphelper::removeElementAt( rCtrls, n ); | |
| return xCtrl; | |
| } | |
| } | |
| return Reference< XControl > (); | |
| } |