| /************************************************************** |
| * |
| * 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_vcl.hxx" |
| |
| #include <tools/debug.hxx> |
| |
| #include <svdata.hxx> |
| #include <window.h> |
| |
| #include <vcl/event.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/tabpage.hxx> |
| #include <vcl/tabctrl.hxx> |
| #include <vcl/tabdlg.hxx> |
| #include <vcl/button.hxx> |
| |
| #include <vcl/unohelp.hxx> |
| #include <com/sun/star/i18n/XCharacterClassification.hpp> |
| |
| using namespace ::com::sun::star; |
| |
| // ======================================================================= |
| |
| static sal_Bool ImplHasIndirectTabParent( Window* pWindow ) |
| { |
| // The window has inderect tab parent if it is included in tab hierarchy |
| // of the indirect parent window |
| |
| return ( pWindow && pWindow->GetParent() |
| && ( pWindow->GetParent()->ImplGetWindow()->GetStyle() & WB_CHILDDLGCTRL ) ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static Window* ImplGetTopParentOfTabHierarchy( Window* pParent ) |
| { |
| // The method allows to find the most close parent containing all the |
| // window from the current tab-hierarchy |
| // The direct parent should be provided as a parameter here |
| |
| Window* pResult = pParent; |
| |
| if ( pResult ) |
| { |
| while ( pResult->GetParent() && ( pResult->ImplGetWindow()->GetStyle() & WB_CHILDDLGCTRL ) ) |
| pResult = pResult->GetParent(); |
| } |
| |
| return pResult; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static Window* ImplGetSubChildWindow( Window* pParent, sal_uInt16 n, sal_uInt16& nIndex ) |
| { |
| Window* pTabPage = NULL; |
| Window* pFoundWindow = NULL; |
| |
| Window* pWindow = pParent->GetWindow( WINDOW_FIRSTCHILD ); |
| Window* pNextWindow = pWindow; |
| while ( pWindow ) |
| { |
| pWindow = pWindow->ImplGetWindow(); |
| |
| // Unsichtbare und disablte Fenster werden uebersprungen |
| if ( pTabPage || pWindow->IsVisible() ) |
| { |
| // Wenn das letzte Control ein TabControl war, wird von |
| // diesem die TabPage genommen |
| if ( pTabPage ) |
| { |
| pFoundWindow = ImplGetSubChildWindow( pTabPage, n, nIndex ); |
| pTabPage = NULL; |
| } |
| else |
| { |
| pFoundWindow = pWindow; |
| |
| // Bei einem TabControl sich die aktuelle TabPage merken, |
| // damit diese dann genommen wird |
| if ( pWindow->GetType() == WINDOW_TABCONTROL ) |
| { |
| TabControl* pTabControl = ((TabControl*)pWindow); |
| // Feststellen, ob TabPage Child vom TabControl ist |
| // und auch noch existiert (deshalb durch Vergleich, |
| // indem alle ChildFenster getestet werden). Denn es |
| // kann sein, das TabPages schon in einem Dialog-Dtor |
| // zerstoert wurden, obwohl das TabControl noch |
| // existiert. |
| TabPage* pTempTabPage = pTabControl->GetTabPage( pTabControl->GetCurPageId() ); |
| if ( pTempTabPage ) |
| { |
| Window* pTempWindow = pTabControl->GetWindow( WINDOW_FIRSTCHILD ); |
| while ( pTempWindow ) |
| { |
| if ( pTempWindow->ImplGetWindow() == pTempTabPage ) |
| { |
| pTabPage = pTempTabPage; |
| break; |
| } |
| pTempWindow = pTempWindow->GetWindow( WINDOW_NEXT ); |
| } |
| } |
| } |
| else if ( ( pWindow->GetStyle() & WB_DIALOGCONTROL ) |
| || ( pWindow->GetStyle() & WB_CHILDDLGCTRL ) ) |
| pFoundWindow = ImplGetSubChildWindow( pWindow, n, nIndex ); |
| } |
| |
| if ( n == nIndex ) |
| return pFoundWindow; |
| nIndex++; |
| } |
| |
| if ( pTabPage ) |
| pWindow = pTabPage; |
| else |
| { |
| pWindow = pNextWindow->GetWindow( WINDOW_NEXT ); |
| pNextWindow = pWindow; |
| } |
| } |
| |
| nIndex--; |
| return pFoundWindow; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static Window* ImplGetChildWindow( Window* pParent, sal_uInt16 n, sal_uInt16& nIndex, sal_Bool bTestEnable ) |
| { |
| pParent = ImplGetTopParentOfTabHierarchy( pParent ); |
| |
| nIndex = 0; |
| Window* pWindow = ImplGetSubChildWindow( pParent, n, nIndex ); |
| if ( bTestEnable ) |
| { |
| sal_uInt16 n2 = nIndex; |
| while ( pWindow && (!pWindow->IsEnabled() || !pWindow->IsInputEnabled()) ) |
| { |
| n2 = nIndex+1; |
| nIndex = 0; |
| pWindow = ImplGetSubChildWindow( pParent, n2, nIndex ); |
| if ( nIndex < n2 ) |
| break; |
| } |
| |
| if ( (nIndex < n2) && n ) |
| { |
| do |
| { |
| n--; |
| nIndex = 0; |
| pWindow = ImplGetSubChildWindow( pParent, n, nIndex ); |
| } |
| while ( pWindow && n && (!pWindow->IsEnabled() || !pWindow->IsInputEnabled()) ); |
| } |
| } |
| return pWindow; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static Window* ImplGetNextWindow( Window* pParent, sal_uInt16 n, sal_uInt16& nIndex, sal_Bool bTestEnable ) |
| { |
| Window* pWindow = ImplGetChildWindow( pParent, n+1, nIndex, bTestEnable ); |
| if ( n == nIndex ) |
| { |
| n = 0; |
| pWindow = ImplGetChildWindow( pParent, n, nIndex, bTestEnable ); |
| } |
| return pWindow; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Window* Window::ImplGetDlgWindow( sal_uInt16 nIndex, sal_uInt16 nType, |
| sal_uInt16 nFormStart, sal_uInt16 nFormEnd, |
| sal_uInt16* pIndex ) |
| { |
| DBG_ASSERT( (nIndex >= nFormStart) && (nIndex <= nFormEnd), |
| "Window::ImplGetDlgWindow() - nIndex not in Form" ); |
| |
| Window* pWindow = NULL; |
| sal_uInt16 i; |
| sal_uInt16 nTemp; |
| sal_uInt16 nStartIndex; |
| |
| if ( nType == DLGWINDOW_PREV ) |
| { |
| i = nIndex; |
| do |
| { |
| if ( i > nFormStart ) |
| i--; |
| else |
| i = nFormEnd; |
| pWindow = ImplGetChildWindow( this, i, nTemp, sal_True ); |
| if ( !pWindow ) |
| break; |
| if ( (i == nTemp) && (pWindow->GetStyle() & WB_TABSTOP) ) |
| break; |
| } |
| while ( i != nIndex ); |
| } |
| else |
| { |
| i = nIndex; |
| pWindow = ImplGetChildWindow( this, i, i, (nType == DLGWINDOW_FIRST) ); |
| if ( pWindow ) |
| { |
| nStartIndex = i; |
| |
| if ( nType == DLGWINDOW_NEXT ) |
| { |
| if ( i < nFormEnd ) |
| { |
| pWindow = ImplGetNextWindow( this, i, i, sal_True ); |
| if ( (i > nFormEnd) || (i < nFormStart) ) |
| pWindow = ImplGetChildWindow( this, nFormStart, i, sal_True ); |
| } |
| else |
| pWindow = ImplGetChildWindow( this, nFormStart, i, sal_True ); |
| } |
| |
| if ( i <= nFormEnd ) |
| { |
| // 2ten Index mitfuehren, falls alle Controls disablte |
| sal_uInt16 nStartIndex2 = i; |
| sal_uInt16 nOldIndex = i+1; |
| |
| do |
| { |
| if ( pWindow->GetStyle() & WB_TABSTOP ) |
| break; |
| if( i == nOldIndex ) // only disabled controls ? |
| { |
| i = nStartIndex2; |
| break; |
| } |
| nOldIndex = i; |
| if ( (i > nFormEnd) || (i < nFormStart) ) |
| pWindow = ImplGetChildWindow( this, nFormStart, i, sal_True ); |
| else |
| pWindow = ImplGetNextWindow( this, i, i, sal_True ); |
| } |
| while ( (i != nStartIndex) && (i != nStartIndex2) ); |
| |
| if ( (i == nStartIndex2) && |
| (!(pWindow->GetStyle() & WB_TABSTOP) || !pWindow->IsEnabled()) ) |
| i = nStartIndex; |
| } |
| } |
| |
| if ( nType == DLGWINDOW_FIRST ) |
| { |
| if ( pWindow ) |
| { |
| if ( pWindow->GetType() == WINDOW_TABCONTROL ) |
| { |
| Window* pNextWindow = ImplGetDlgWindow( i, DLGWINDOW_NEXT ); |
| if ( pNextWindow ) |
| { |
| if ( pWindow->IsChild( pNextWindow ) ) |
| pWindow = pNextWindow; |
| } |
| } |
| |
| if ( !(pWindow->GetStyle() & WB_TABSTOP) ) |
| pWindow = NULL; |
| } |
| } |
| } |
| |
| if ( pIndex ) |
| *pIndex = i; |
| |
| return pWindow; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static Window* ImplFindDlgCtrlWindow( Window* pParent, Window* pWindow, sal_uInt16& rIndex, |
| sal_uInt16& rFormStart, sal_uInt16& rFormEnd ) |
| { |
| Window* pSWindow; |
| Window* pSecondWindow = NULL; |
| Window* pTempWindow = NULL; |
| sal_uInt16 i; |
| sal_uInt16 nSecond_i = 0; |
| sal_uInt16 nFormStart = 0; |
| sal_uInt16 nSecondFormStart = 0; |
| sal_uInt16 nFormEnd; |
| |
| // Focus-Fenster in der Child-Liste suchen |
| Window* pFirstChildWindow = pSWindow = ImplGetChildWindow( pParent, 0, i, sal_False ); |
| |
| if( pWindow == NULL ) |
| pWindow = pSWindow; |
| |
| while ( pSWindow ) |
| { |
| // the DialogControlStart mark is only accepted for the direct children |
| if ( !ImplHasIndirectTabParent( pSWindow ) |
| && pSWindow->ImplGetWindow()->IsDialogControlStart() ) |
| nFormStart = i; |
| |
| // SecondWindow wegen zusammengesetzten Controls wie |
| // ComboBoxen und Feldern |
| if ( pSWindow->ImplIsWindowOrChild( pWindow ) ) |
| { |
| pSecondWindow = pSWindow; |
| nSecond_i = i; |
| nSecondFormStart = nFormStart; |
| if ( pSWindow == pWindow ) |
| break; |
| } |
| |
| pSWindow = ImplGetNextWindow( pParent, i, i, sal_False ); |
| if ( !i ) |
| pSWindow = NULL; |
| } |
| |
| if ( !pSWindow ) |
| { |
| // Fenster nicht gefunden, dann koennen wir auch keine |
| // Steuerung uebernehmen |
| if ( !pSecondWindow ) |
| return NULL; |
| else |
| { |
| pSWindow = pSecondWindow; |
| i = nSecond_i; |
| nFormStart = nSecondFormStart; |
| } |
| } |
| |
| // Start-Daten setzen |
| rIndex = i; |
| rFormStart = nFormStart; |
| |
| // Formularende suchen |
| nFormEnd = nFormStart; |
| pTempWindow = pSWindow; |
| sal_Int32 nIteration = 0; |
| do |
| { |
| nFormEnd = i; |
| pTempWindow = ImplGetNextWindow( pParent, i, i, sal_False ); |
| |
| // the DialogControlStart mark is only accepted for the direct children |
| if ( !i |
| || ( pTempWindow && !ImplHasIndirectTabParent( pTempWindow ) |
| && pTempWindow->ImplGetWindow()->IsDialogControlStart() ) ) |
| break; |
| |
| if ( pTempWindow && pTempWindow == pFirstChildWindow ) |
| { |
| // It is possible to go through the begin of hierarchy once |
| // while looking for DialogControlStart mark. |
| // If it happens second time, it looks like an endless loop, |
| // that should be impossible, but just for the case... |
| nIteration++; |
| if ( nIteration >= 2 ) |
| { |
| // this is an unexpected scenario |
| DBG_ASSERT( sal_False, "It seems to be an endless loop!" ); |
| rFormStart = 0; |
| break; |
| } |
| } |
| } |
| while ( pTempWindow ); |
| rFormEnd = nFormEnd; |
| |
| return pSWindow; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static Window* ImplFindAccelWindow( Window* pParent, sal_uInt16& rIndex, xub_Unicode cCharCode, |
| sal_uInt16 nFormStart, sal_uInt16 nFormEnd, sal_Bool bCheckEnable = sal_True ) |
| { |
| DBG_ASSERT( (rIndex >= nFormStart) && (rIndex <= nFormEnd), |
| "Window::ImplFindAccelWindow() - rIndex not in Form" ); |
| |
| xub_Unicode cCompareChar; |
| sal_uInt16 nStart = rIndex; |
| sal_uInt16 i = rIndex; |
| int bSearch = sal_True; |
| Window* pWindow; |
| |
| // MT: Where can we keep the CharClass?! |
| static uno::Reference< i18n::XCharacterClassification > xCharClass; |
| if ( !xCharClass.is() ) |
| xCharClass = vcl::unohelper::CreateCharacterClassification(); |
| |
| const ::com::sun::star::lang::Locale& rLocale = Application::GetSettings().GetUILocale(); |
| cCharCode = xCharClass->toUpper( String(cCharCode), 0, 1, rLocale )[0]; |
| |
| if ( i < nFormEnd ) |
| pWindow = ImplGetNextWindow( pParent, i, i, sal_True ); |
| else |
| pWindow = ImplGetChildWindow( pParent, nFormStart, i, sal_True ); |
| while( bSearch && pWindow ) |
| { |
| const XubString aStr = pWindow->GetText(); |
| sal_uInt16 nPos = aStr.Search( '~' ); |
| while ( nPos != STRING_NOTFOUND ) |
| { |
| cCompareChar = aStr.GetChar( nPos+1 ); |
| cCompareChar = xCharClass->toUpper( String(cCompareChar), 0, 1, rLocale )[0]; |
| if ( cCompareChar == cCharCode ) |
| { |
| // Bei Static-Controls auf das naechste Controlm weiterschalten |
| if ( (pWindow->GetType() == WINDOW_FIXEDTEXT) || |
| (pWindow->GetType() == WINDOW_FIXEDLINE) || |
| (pWindow->GetType() == WINDOW_GROUPBOX) ) |
| pWindow = pParent->ImplGetDlgWindow( i, DLGWINDOW_NEXT ); |
| rIndex = i; |
| return pWindow; |
| } |
| nPos = aStr.Search( '~', nPos+1 ); |
| } |
| |
| // #i93011# it would have made sense to have this really recursive |
| // right from the start. However this would cause unpredictable side effects now |
| // so instead we have a style bit for some child windows, that want their |
| // children checked for accelerators |
| if( (pWindow->GetStyle() & WB_CHILDDLGCTRL) != 0 ) |
| { |
| sal_uInt16 nChildIndex; |
| sal_uInt16 nChildFormStart; |
| sal_uInt16 nChildFormEnd; |
| |
| // get form start and end |
| ::ImplFindDlgCtrlWindow( pWindow, NULL, |
| nChildIndex, nChildFormStart, nChildFormEnd ); |
| Window* pAccelWin = ImplFindAccelWindow( pWindow, nChildIndex, cCharCode, |
| nChildFormStart, nChildFormEnd, |
| bCheckEnable ); |
| if( pAccelWin ) |
| return pAccelWin; |
| } |
| |
| if ( i == nStart ) |
| break; |
| |
| if ( i < nFormEnd ) |
| { |
| pWindow = ImplGetNextWindow( pParent, i, i, bCheckEnable ); |
| if( ! pWindow ) |
| pWindow = ImplGetChildWindow( pParent, nFormStart, i, bCheckEnable ); |
| } |
| else |
| pWindow = ImplGetChildWindow( pParent, nFormStart, i, bCheckEnable ); |
| } |
| |
| return NULL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Window::ImplControlFocus( sal_uInt16 nFlags ) |
| { |
| if ( nFlags & GETFOCUS_MNEMONIC ) |
| { |
| if ( GetType() == WINDOW_RADIOBUTTON ) |
| { |
| if ( !((RadioButton*)this)->IsChecked() ) |
| ((RadioButton*)this)->ImplCallClick( sal_True, nFlags ); |
| else |
| ImplGrabFocus( nFlags ); |
| } |
| else |
| { |
| ImplGrabFocus( nFlags ); |
| if ( nFlags & GETFOCUS_UNIQUEMNEMONIC ) |
| { |
| if ( GetType() == WINDOW_CHECKBOX ) |
| ((CheckBox*)this)->ImplCheck(); |
| else if ( mpWindowImpl->mbPushButton ) |
| { |
| ((PushButton*)this)->SetPressed( sal_True ); |
| ((PushButton*)this)->SetPressed( sal_False ); |
| ((PushButton*)this)->Click(); |
| } |
| } |
| } |
| } |
| else |
| { |
| if ( GetType() == WINDOW_RADIOBUTTON ) |
| { |
| if ( !((RadioButton*)this)->IsChecked() ) |
| ((RadioButton*)this)->ImplCallClick( sal_True, nFlags ); |
| else |
| ImplGrabFocus( nFlags ); |
| } |
| else |
| ImplGrabFocus( nFlags ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| sal_Bool Window::ImplDlgCtrl( const KeyEvent& rKEvt, sal_Bool bKeyInput ) |
| { |
| KeyCode aKeyCode = rKEvt.GetKeyCode(); |
| sal_uInt16 nKeyCode = aKeyCode.GetCode(); |
| Window* pSWindow; |
| Window* pTempWindow; |
| Window* pButtonWindow; |
| sal_uInt16 i; |
| sal_uInt16 iButton; |
| sal_uInt16 iButtonStart; |
| sal_uInt16 iTemp; |
| sal_uInt16 nIndex; |
| sal_uInt16 nFormStart; |
| sal_uInt16 nFormEnd; |
| sal_uInt16 nDlgCtrlFlags; |
| |
| // Ohne Focus-Window koennen wir auch keine Steuerung uebernehmen |
| Window* pFocusWindow = Application::GetFocusWindow(); |
| if ( !pFocusWindow || !ImplIsWindowOrChild( pFocusWindow ) ) |
| return sal_False; |
| |
| // Focus-Fenster in der Child-Liste suchen |
| pSWindow = ::ImplFindDlgCtrlWindow( this, pFocusWindow, |
| nIndex, nFormStart, nFormEnd ); |
| if ( !pSWindow ) |
| return sal_False; |
| i = nIndex; |
| |
| nDlgCtrlFlags = 0; |
| pTempWindow = pSWindow; |
| do |
| { |
| nDlgCtrlFlags |= pTempWindow->GetDialogControlFlags(); |
| if ( pTempWindow == this ) |
| break; |
| pTempWindow = pTempWindow->ImplGetParent(); |
| } |
| while ( pTempWindow ); |
| |
| pButtonWindow = NULL; |
| |
| if ( nKeyCode == KEY_RETURN ) |
| { |
| // Wir suchen zuerst nach einem DefPushButton/CancelButton |
| pButtonWindow = ImplGetChildWindow( this, nFormStart, iButton, sal_True ); |
| iButtonStart = iButton; |
| while ( pButtonWindow ) |
| { |
| if ( (pButtonWindow->GetStyle() & WB_DEFBUTTON) && |
| pButtonWindow->mpWindowImpl->mbPushButton ) |
| break; |
| |
| pButtonWindow = ImplGetNextWindow( this, iButton, iButton, sal_True ); |
| if ( (iButton <= iButtonStart) || (iButton > nFormEnd) ) |
| pButtonWindow = NULL; |
| } |
| |
| if ( bKeyInput && !pButtonWindow && (nDlgCtrlFlags & WINDOW_DLGCTRL_RETURN) ) |
| { |
| sal_uInt16 nType; |
| sal_uInt16 nGetFocusFlags = GETFOCUS_TAB; |
| sal_uInt16 nNewIndex; |
| sal_uInt16 iStart; |
| if ( aKeyCode.IsShift() ) |
| { |
| nType = DLGWINDOW_PREV; |
| nGetFocusFlags |= GETFOCUS_BACKWARD; |
| } |
| else |
| { |
| nType = DLGWINDOW_NEXT; |
| nGetFocusFlags |= GETFOCUS_FORWARD; |
| } |
| iStart = i; |
| pTempWindow = ImplGetDlgWindow( i, nType, nFormStart, nFormEnd, &nNewIndex ); |
| while ( pTempWindow && (pTempWindow != pSWindow) ) |
| { |
| if ( !pTempWindow->mpWindowImpl->mbPushButton ) |
| { |
| // Around-Flag ermitteln |
| if ( nType == DLGWINDOW_PREV ) |
| { |
| if ( nNewIndex > iStart ) |
| nGetFocusFlags |= GETFOCUS_AROUND; |
| } |
| else |
| { |
| if ( nNewIndex < iStart ) |
| nGetFocusFlags |= GETFOCUS_AROUND; |
| } |
| pTempWindow->ImplControlFocus( nGetFocusFlags ); |
| return sal_True; |
| } |
| else |
| { |
| i = nNewIndex; |
| pTempWindow = ImplGetDlgWindow( i, nType, nFormStart, nFormEnd, &nNewIndex ); |
| } |
| if ( (i <= iStart) || (i > nFormEnd) ) |
| pTempWindow = NULL; |
| } |
| // Wenn es das gleiche Fenster ist, ein Get/LoseFocus |
| // simulieren, falls AROUND ausgewertet wird |
| if ( pTempWindow && (pTempWindow == pSWindow) ) |
| { |
| NotifyEvent aNEvt1( EVENT_LOSEFOCUS, pSWindow ); |
| if ( !ImplCallPreNotify( aNEvt1 ) ) |
| pSWindow->LoseFocus(); |
| pSWindow->mpWindowImpl->mnGetFocusFlags = nGetFocusFlags | GETFOCUS_AROUND; |
| NotifyEvent aNEvt2( EVENT_GETFOCUS, pSWindow ); |
| if ( !ImplCallPreNotify( aNEvt2 ) ) |
| pSWindow->GetFocus(); |
| pSWindow->mpWindowImpl->mnGetFocusFlags = 0; |
| return sal_True; |
| } |
| } |
| } |
| else if ( nKeyCode == KEY_ESCAPE ) |
| { |
| // Wir suchen zuerst nach einem DefPushButton/CancelButton |
| pButtonWindow = ImplGetChildWindow( this, nFormStart, iButton, sal_True ); |
| iButtonStart = iButton; |
| while ( pButtonWindow ) |
| { |
| if ( pButtonWindow->GetType() == WINDOW_CANCELBUTTON ) |
| break; |
| |
| pButtonWindow = ImplGetNextWindow( this, iButton, iButton, sal_True ); |
| if ( (iButton <= iButtonStart) || (iButton > nFormEnd) ) |
| pButtonWindow = NULL; |
| } |
| |
| if ( bKeyInput && mpWindowImpl->mpDlgCtrlDownWindow ) |
| { |
| if ( mpWindowImpl->mpDlgCtrlDownWindow != pButtonWindow ) |
| { |
| ((PushButton*)mpWindowImpl->mpDlgCtrlDownWindow)->SetPressed( sal_False ); |
| mpWindowImpl->mpDlgCtrlDownWindow = NULL; |
| return sal_True; |
| } |
| } |
| } |
| else if ( bKeyInput ) |
| { |
| if ( nKeyCode == KEY_TAB ) |
| { |
| // keine Alt-Taste abfangen, wegen Windows |
| if ( !aKeyCode.IsMod2() ) |
| { |
| sal_uInt16 nType; |
| sal_uInt16 nGetFocusFlags = GETFOCUS_TAB; |
| sal_uInt16 nNewIndex; |
| sal_Bool bFormular = sal_False; |
| |
| // Bei Ctrl-Tab erstmal testen, ob zwischen Formularen |
| // gesprungen werden soll |
| if ( aKeyCode.IsMod1() ) |
| { |
| // Gruppe suchen |
| Window* pFormularFirstWindow = NULL; |
| Window* pLastFormularFirstWindow = NULL; |
| pTempWindow = ImplGetChildWindow( this, 0, iTemp, sal_False ); |
| Window* pPrevFirstFormularFirstWindow = NULL; |
| Window* pFirstFormularFirstWindow = pTempWindow; |
| while ( pTempWindow ) |
| { |
| if ( pTempWindow->ImplGetWindow()->IsDialogControlStart() ) |
| { |
| if ( iTemp != 0 ) |
| bFormular = sal_True; |
| if ( aKeyCode.IsShift() ) |
| { |
| if ( iTemp <= nIndex ) |
| pFormularFirstWindow = pPrevFirstFormularFirstWindow; |
| pPrevFirstFormularFirstWindow = pTempWindow; |
| } |
| else |
| { |
| if ( (iTemp > nIndex) && !pFormularFirstWindow ) |
| pFormularFirstWindow = pTempWindow; |
| } |
| pLastFormularFirstWindow = pTempWindow; |
| } |
| |
| pTempWindow = ImplGetNextWindow( this, iTemp, iTemp, sal_False ); |
| if ( !iTemp ) |
| pTempWindow = NULL; |
| } |
| |
| if ( bFormular ) |
| { |
| if ( !pFormularFirstWindow ) |
| { |
| if ( aKeyCode.IsShift() ) |
| pFormularFirstWindow = pLastFormularFirstWindow; |
| else |
| pFormularFirstWindow = pFirstFormularFirstWindow; |
| } |
| |
| sal_uInt16 nFoundFormStart = 0; |
| sal_uInt16 nFoundFormEnd = 0; |
| sal_uInt16 nTempIndex = 0; |
| if ( ::ImplFindDlgCtrlWindow( this, pFormularFirstWindow, nTempIndex, |
| nFoundFormStart, nFoundFormEnd ) ) |
| { |
| nTempIndex = nFoundFormStart; |
| pFormularFirstWindow = ImplGetDlgWindow( nTempIndex, DLGWINDOW_FIRST, nFoundFormStart, nFoundFormEnd ); |
| if ( pFormularFirstWindow ) |
| { |
| pFormularFirstWindow->ImplControlFocus(); |
| return sal_True; |
| } |
| } |
| } |
| } |
| |
| if ( !bFormular ) |
| { |
| // Only use Ctrl-TAB if it was allowed for the whole |
| // dialog or for the current control (#103667#) |
| if ( !aKeyCode.IsMod1() || (nDlgCtrlFlags & WINDOW_DLGCTRL_MOD1TAB) || |
| ( pSWindow->GetStyle() & WINDOW_DLGCTRL_MOD1TAB) ) |
| { |
| if ( aKeyCode.IsShift() ) |
| { |
| nType = DLGWINDOW_PREV; |
| nGetFocusFlags |= GETFOCUS_BACKWARD; |
| } |
| else |
| { |
| nType = DLGWINDOW_NEXT; |
| nGetFocusFlags |= GETFOCUS_FORWARD; |
| } |
| Window* pWindow = ImplGetDlgWindow( i, nType, nFormStart, nFormEnd, &nNewIndex ); |
| // Wenn es das gleiche Fenster ist, ein Get/LoseFocus |
| // simulieren, falls AROUND ausgewertet wird |
| if ( pWindow == pSWindow ) |
| { |
| NotifyEvent aNEvt1( EVENT_LOSEFOCUS, pSWindow ); |
| if ( !ImplCallPreNotify( aNEvt1 ) ) |
| pSWindow->LoseFocus(); |
| pSWindow->mpWindowImpl->mnGetFocusFlags = nGetFocusFlags | GETFOCUS_AROUND; |
| NotifyEvent aNEvt2( EVENT_GETFOCUS, pSWindow ); |
| if ( !ImplCallPreNotify( aNEvt2 ) ) |
| pSWindow->GetFocus(); |
| pSWindow->mpWindowImpl->mnGetFocusFlags = 0; |
| return sal_True; |
| } |
| else if ( pWindow ) |
| { |
| // Around-Flag ermitteln |
| if ( nType == DLGWINDOW_PREV ) |
| { |
| if ( nNewIndex > i ) |
| nGetFocusFlags |= GETFOCUS_AROUND; |
| } |
| else |
| { |
| if ( nNewIndex < i ) |
| nGetFocusFlags |= GETFOCUS_AROUND; |
| } |
| pWindow->ImplControlFocus( nGetFocusFlags ); |
| return sal_True; |
| } |
| } |
| } |
| } |
| } |
| else if ( (nKeyCode == KEY_LEFT) || (nKeyCode == KEY_UP) ) |
| { |
| Window* pWindow = pSWindow; |
| WinBits nStyle = pSWindow->GetStyle(); |
| if ( !(nStyle & WB_GROUP) ) |
| { |
| pWindow = pWindow->GetWindow( WINDOW_PREV ); |
| while ( pWindow ) |
| { |
| pWindow = pWindow->ImplGetWindow(); |
| |
| nStyle = pWindow->GetStyle(); |
| |
| if ( pWindow->IsVisible() && pWindow->IsEnabled() && pWindow->IsInputEnabled() ) |
| { |
| if ( pWindow != pSWindow ) |
| pWindow->ImplControlFocus( GETFOCUS_CURSOR | GETFOCUS_BACKWARD ); |
| return sal_True; |
| } |
| |
| if ( nStyle & WB_GROUP ) |
| break; |
| |
| pWindow = pWindow->GetWindow( WINDOW_PREV ); |
| } |
| } |
| } |
| else if ( (nKeyCode == KEY_RIGHT) || (nKeyCode == KEY_DOWN) ) |
| { |
| Window* pWindow; |
| WinBits nStyle; |
| pWindow = pSWindow->GetWindow( WINDOW_NEXT ); |
| while ( pWindow ) |
| { |
| pWindow = pWindow->ImplGetWindow(); |
| |
| nStyle = pWindow->GetStyle(); |
| |
| if ( nStyle & WB_GROUP ) |
| break; |
| |
| //Solution:Pure window shouldn't get window after controls such as buttons. |
| //if ( pWindow->IsVisible() && pWindow->IsEnabled() && pWindow->IsInputEnabled() ) |
| if ( pWindow->IsVisible() && pWindow->IsEnabled() && |
| pWindow->IsInputEnabled() && ( |
| pWindow->GetType() != WINDOW_WINDOW && |
| pWindow->GetType() != WINDOW_SYSWINDOW && |
| pWindow->GetType() != WINDOW_WORKWINDOW && |
| pWindow->GetType() != WINDOW_CONTROL |
| ) |
| ) |
| { |
| pWindow->ImplControlFocus( GETFOCUS_CURSOR | GETFOCUS_BACKWARD ); |
| return sal_True; |
| } |
| |
| pWindow = pWindow->GetWindow( WINDOW_NEXT ); |
| } |
| } |
| else |
| { |
| xub_Unicode c = rKEvt.GetCharCode(); |
| if ( c ) |
| { |
| pSWindow = ::ImplFindAccelWindow( this, i, c, nFormStart, nFormEnd ); |
| if ( pSWindow ) |
| { |
| sal_uInt16 nGetFocusFlags = GETFOCUS_MNEMONIC; |
| if ( pSWindow == ::ImplFindAccelWindow( this, i, c, nFormStart, nFormEnd ) ) |
| nGetFocusFlags |= GETFOCUS_UNIQUEMNEMONIC; |
| pSWindow->ImplControlFocus( nGetFocusFlags ); |
| return sal_True; |
| } |
| } |
| } |
| } |
| |
| if ( pButtonWindow && pButtonWindow->IsVisible() && pButtonWindow->IsEnabled() && pButtonWindow->IsInputEnabled() ) |
| { |
| if ( bKeyInput ) |
| { |
| if ( mpWindowImpl->mpDlgCtrlDownWindow && (mpWindowImpl->mpDlgCtrlDownWindow != pButtonWindow) ) |
| { |
| ((PushButton*)mpWindowImpl->mpDlgCtrlDownWindow)->SetPressed( sal_False ); |
| mpWindowImpl->mpDlgCtrlDownWindow = NULL; |
| } |
| |
| ((PushButton*)pButtonWindow)->SetPressed( sal_True ); |
| mpWindowImpl->mpDlgCtrlDownWindow = pButtonWindow; |
| } |
| else if ( mpWindowImpl->mpDlgCtrlDownWindow == pButtonWindow ) |
| { |
| mpWindowImpl->mpDlgCtrlDownWindow = NULL; |
| ((PushButton*)pButtonWindow)->SetPressed( sal_False ); |
| ((PushButton*)pButtonWindow)->Click(); |
| } |
| |
| return sal_True; |
| } |
| |
| return sal_False; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| // checks if this window has dialog control |
| sal_Bool Window::ImplHasDlgCtrl() |
| { |
| Window* pDlgCtrlParent; |
| Window* pDlgCtrl; |
| |
| // lookup window for dialog control |
| pDlgCtrl = this; |
| pDlgCtrlParent = ImplGetParent(); |
| while ( pDlgCtrlParent && |
| !pDlgCtrlParent->ImplIsOverlapWindow() && |
| ((pDlgCtrlParent->GetStyle() & (WB_DIALOGCONTROL | WB_NODIALOGCONTROL)) != WB_DIALOGCONTROL) ) |
| pDlgCtrlParent = pDlgCtrlParent->ImplGetParent(); |
| |
| if ( !pDlgCtrlParent || ((pDlgCtrlParent->GetStyle() & (WB_DIALOGCONTROL | WB_NODIALOGCONTROL)) != WB_DIALOGCONTROL) ) |
| return sal_False; |
| else |
| return sal_True; |
| } |
| |
| void Window::ImplDlgCtrlNextWindow() |
| { |
| Window* pDlgCtrlParent; |
| Window* pDlgCtrl; |
| Window* pSWindow; |
| sal_uInt16 nIndex; |
| sal_uInt16 nFormStart; |
| sal_uInt16 nFormEnd; |
| |
| // lookup window for dialog control |
| pDlgCtrl = this; |
| pDlgCtrlParent = ImplGetParent(); |
| while ( pDlgCtrlParent && |
| !pDlgCtrlParent->ImplIsOverlapWindow() && |
| ((pDlgCtrlParent->GetStyle() & (WB_DIALOGCONTROL | WB_NODIALOGCONTROL)) != WB_DIALOGCONTROL) ) |
| pDlgCtrlParent = pDlgCtrlParent->ImplGetParent(); |
| |
| if ( !pDlgCtrlParent || (GetStyle() & WB_NODIALOGCONTROL) || ((pDlgCtrlParent->GetStyle() & (WB_DIALOGCONTROL | WB_NODIALOGCONTROL)) != WB_DIALOGCONTROL) ) |
| return; |
| |
| // lookup window in child list |
| pSWindow = ::ImplFindDlgCtrlWindow( pDlgCtrlParent, pDlgCtrl, |
| nIndex, nFormStart, nFormEnd ); |
| if ( !pSWindow ) |
| return; |
| |
| Window* pWindow = pDlgCtrlParent->ImplGetDlgWindow( nIndex, DLGWINDOW_NEXT, nFormStart, nFormEnd ); |
| if ( pWindow && (pWindow != pSWindow) ) |
| pWindow->ImplControlFocus(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static void ImplDlgCtrlUpdateDefButton( Window* pParent, Window* pFocusWindow, |
| sal_Bool bGetFocus ) |
| { |
| PushButton* pOldDefButton = NULL; |
| PushButton* pNewDefButton = NULL; |
| Window* pSWindow; |
| sal_uInt16 i; |
| sal_uInt16 nFormStart; |
| sal_uInt16 nFormEnd; |
| |
| // Formular suchen |
| pSWindow = ::ImplFindDlgCtrlWindow( pParent, pFocusWindow, i, nFormStart, nFormEnd ); |
| if ( !pSWindow ) |
| { |
| nFormStart = 0; |
| nFormEnd = 0xFFFF; |
| } |
| |
| pSWindow = ImplGetChildWindow( pParent, nFormStart, i, sal_False ); |
| while ( pSWindow ) |
| { |
| if ( pSWindow->ImplIsPushButton() ) |
| { |
| PushButton* pPushButton = (PushButton*)pSWindow; |
| if ( pPushButton->ImplIsDefButton() ) |
| pOldDefButton = pPushButton; |
| if ( pPushButton->HasChildPathFocus() ) |
| pNewDefButton = pPushButton; |
| else if ( !pNewDefButton && (pPushButton->GetStyle() & WB_DEFBUTTON) ) |
| pNewDefButton = pPushButton; |
| } |
| |
| pSWindow = ImplGetNextWindow( pParent, i, i, sal_False ); |
| if ( !i || (i > nFormEnd) ) |
| pSWindow = NULL; |
| } |
| |
| if ( !bGetFocus ) |
| { |
| sal_uInt16 nDummy; |
| Window* pNewFocusWindow = Application::GetFocusWindow(); |
| if ( !pNewFocusWindow || !pParent->ImplIsWindowOrChild( pNewFocusWindow ) ) |
| pNewDefButton = NULL; |
| else if ( !::ImplFindDlgCtrlWindow( pParent, pNewFocusWindow, i, nDummy, nDummy ) || |
| (i < nFormStart) || (i > nFormEnd) ) |
| pNewDefButton = NULL; |
| } |
| |
| if ( pOldDefButton != pNewDefButton ) |
| { |
| if ( pOldDefButton ) |
| pOldDefButton->ImplSetDefButton( sal_False ); |
| if ( pNewDefButton ) |
| pNewDefButton->ImplSetDefButton( sal_True ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| void Window::ImplDlgCtrlFocusChanged( Window* pWindow, sal_Bool bGetFocus ) |
| { |
| if ( mpWindowImpl->mpDlgCtrlDownWindow && !bGetFocus ) |
| { |
| ((PushButton*)mpWindowImpl->mpDlgCtrlDownWindow)->SetPressed( sal_False ); |
| mpWindowImpl->mpDlgCtrlDownWindow = NULL; |
| } |
| |
| ImplDlgCtrlUpdateDefButton( this, pWindow, bGetFocus ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Window* Window::ImplFindDlgCtrlWindow( Window* pWindow ) |
| { |
| sal_uInt16 nIndex; |
| sal_uInt16 nFormStart; |
| sal_uInt16 nFormEnd; |
| |
| // Focus-Fenster in der Child-Liste suchen und zurueckgeben |
| return ::ImplFindDlgCtrlWindow( this, pWindow, nIndex, nFormStart, nFormEnd ); |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| Window* Window::GetParentLabelFor( const Window* ) const |
| { |
| return NULL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| Window* Window::GetParentLabeledBy( const Window* ) const |
| { |
| return NULL; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static sal_Unicode getAccel( const String& rStr ) |
| { |
| sal_Unicode nChar = 0; |
| sal_uInt16 nPos = 0; |
| do |
| { |
| nPos = rStr.Search( '~', nPos ); |
| if( nPos != STRING_NOTFOUND && nPos < rStr.Len() ) |
| nChar = rStr.GetChar( ++nPos ); |
| else |
| nChar = 0; |
| } while( nChar == '~' ); |
| return nChar; |
| } |
| |
| static Window* ImplGetLabelFor( Window* pFrameWindow, WindowType nMyType, Window* pLabel, sal_Unicode nAccel ) |
| { |
| Window* pWindow = NULL; |
| |
| if( nMyType == WINDOW_FIXEDTEXT || |
| nMyType == WINDOW_FIXEDLINE || |
| nMyType == WINDOW_GROUPBOX ) |
| { |
| // #i100833# MT 2010/02: Group box and fixed lines can also lable a fixed text. |
| // See tools/options/print for example. |
| sal_Bool bThisIsAGroupControl = (nMyType == WINDOW_GROUPBOX) || (nMyType == WINDOW_FIXEDLINE); |
| Window* pSWindow = NULL; |
| // get index, form start and form end |
| sal_uInt16 nIndex=0, nFormStart=0, nFormEnd=0; |
| pSWindow = ::ImplFindDlgCtrlWindow( pFrameWindow, |
| pLabel, |
| nIndex, |
| nFormStart, |
| nFormEnd ); |
| if( nAccel ) |
| { |
| // find the accelerated window |
| pWindow = ::ImplFindAccelWindow( pFrameWindow, |
| nIndex, |
| nAccel, |
| nFormStart, |
| nFormEnd, |
| sal_False ); |
| } |
| else |
| { |
| // find the next control; if that is a fixed text |
| // fixed line or group box, then return NULL |
| while( nIndex < nFormEnd ) |
| { |
| nIndex++; |
| pSWindow = ::ImplGetChildWindow( pFrameWindow, |
| nIndex, |
| nIndex, |
| sal_False ); |
| if( pSWindow && pSWindow->IsVisible() && ! (pSWindow->GetStyle() & WB_NOLABEL) ) |
| { |
| WindowType nType = pSWindow->GetType(); |
| if( nType != WINDOW_FIXEDTEXT && |
| nType != WINDOW_FIXEDLINE && |
| nType != WINDOW_GROUPBOX ) |
| { |
| pWindow = pSWindow; |
| } |
| else if( bThisIsAGroupControl && ( nType == WINDOW_FIXEDTEXT ) ) |
| { |
| pWindow = pSWindow; |
| } |
| break; |
| } |
| } |
| } |
| } |
| |
| return pWindow; |
| } |
| |
| Window* Window::GetAccessibleRelationLabelFor() const |
| { |
| if ( mpWindowImpl->mbDisableAccessibleLabelForRelation ) |
| return NULL; |
| |
| if ( mpWindowImpl->mpAccessibleInfos && mpWindowImpl->mpAccessibleInfos->pLabelForWindow ) |
| return mpWindowImpl->mpAccessibleInfos->pLabelForWindow; |
| |
| |
| Window* pWindow = NULL; |
| Window* pFrameWindow = ImplGetFrameWindow(); |
| |
| WinBits nFrameStyle = pFrameWindow->GetStyle(); |
| if( ! ( nFrameStyle & WB_DIALOGCONTROL ) |
| || ( nFrameStyle & WB_NODIALOGCONTROL ) |
| ) |
| return NULL; |
| |
| if ( mpWindowImpl->mpRealParent ) |
| pWindow = mpWindowImpl->mpRealParent->GetParentLabelFor( this ); |
| |
| if( pWindow ) |
| return pWindow; |
| |
| sal_Unicode nAccel = getAccel( GetText() ); |
| |
| pWindow = ImplGetLabelFor( pFrameWindow, GetType(), const_cast<Window*>(this), nAccel ); |
| if( ! pWindow && mpWindowImpl->mpRealParent ) |
| pWindow = ImplGetLabelFor( mpWindowImpl->mpRealParent, GetType(), const_cast<Window*>(this), nAccel ); |
| return pWindow; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| static Window* ImplGetLabeledBy( Window* pFrameWindow, WindowType nMyType, Window* pLabeled ) |
| { |
| Window* pWindow = NULL; |
| if ( (nMyType != WINDOW_GROUPBOX) && (nMyType != WINDOW_FIXEDLINE) ) |
| { |
| // search for a control that labels this window |
| // a label is considered the last fixed text, fixed line or group box |
| // that comes before this control; with the exception of push buttons |
| // which are labeled only if the fixed text, fixed line or group box |
| // is directly before the control |
| |
| // get form start and form end and index of this control |
| sal_uInt16 nIndex, nFormStart, nFormEnd; |
| Window* pSWindow = ::ImplFindDlgCtrlWindow( pFrameWindow, |
| pLabeled, |
| nIndex, |
| nFormStart, |
| nFormEnd ); |
| if( pSWindow && nIndex != nFormStart ) |
| { |
| if( nMyType == WINDOW_PUSHBUTTON || |
| nMyType == WINDOW_HELPBUTTON || |
| nMyType == WINDOW_OKBUTTON || |
| nMyType == WINDOW_CANCELBUTTON ) |
| { |
| nFormStart = nIndex-1; |
| } |
| for( sal_uInt16 nSearchIndex = nIndex-1; nSearchIndex >= nFormStart; nSearchIndex-- ) |
| { |
| sal_uInt16 nFoundIndex = 0; |
| pSWindow = ::ImplGetChildWindow( pFrameWindow, |
| nSearchIndex, |
| nFoundIndex, |
| sal_False ); |
| if( pSWindow && pSWindow->IsVisible() && !(pSWindow->GetStyle() & WB_NOLABEL) ) |
| { |
| WindowType nType = pSWindow->GetType(); |
| if ( ( nType == WINDOW_FIXEDTEXT || |
| nType == WINDOW_FIXEDLINE || |
| nType == WINDOW_GROUPBOX ) ) |
| { |
| // a fixed text can't be labeld by a fixed text. |
| if ( ( nMyType != WINDOW_FIXEDTEXT ) || ( nType != WINDOW_FIXEDTEXT ) ) |
| pWindow = pSWindow; |
| break; |
| } |
| } |
| if( nFoundIndex > nSearchIndex || nSearchIndex == 0 ) |
| break; |
| } |
| } |
| } |
| return pWindow; |
| } |
| |
| Window* Window::GetAccessibleRelationLabeledBy() const |
| { |
| if ( mpWindowImpl->mbDisableAccessibleLabeledByRelation ) |
| return NULL; |
| |
| if ( mpWindowImpl->mpAccessibleInfos && mpWindowImpl->mpAccessibleInfos->pLabeledByWindow ) |
| return mpWindowImpl->mpAccessibleInfos->pLabeledByWindow; |
| |
| Window* pWindow = NULL; |
| Window* pFrameWindow = ImplGetFrameWindow(); |
| |
| if ( mpWindowImpl->mpRealParent ) |
| { |
| pWindow = mpWindowImpl->mpRealParent->GetParentLabeledBy( this ); |
| |
| if( pWindow ) |
| return pWindow; |
| } |
| |
| // #i62723#, #104191# checkboxes and radiobuttons are not supposed to have labels |
| if( GetType() == WINDOW_CHECKBOX || GetType() == WINDOW_RADIOBUTTON ) |
| return NULL; |
| |
| // if( ! ( GetType() == WINDOW_FIXEDTEXT || |
| // GetType() == WINDOW_FIXEDLINE || |
| // GetType() == WINDOW_GROUPBOX ) ) |
| // #i100833# MT 2010/02: Group box and fixed lines can also lable a fixed text. |
| // See tools/options/print for example. |
| |
| pWindow = ImplGetLabeledBy( pFrameWindow, GetType(), const_cast<Window*>(this) ); |
| if( ! pWindow && mpWindowImpl->mpRealParent ) |
| pWindow = ImplGetLabeledBy( mpWindowImpl->mpRealParent, GetType(), const_cast<Window*>(this) ); |
| |
| return pWindow; |
| } |
| |
| Window* Window::GetAccessibleRelationMemberOf() const |
| { |
| Window* pWindow = NULL; |
| Window* pFrameWindow = GetParent(); |
| if ( !pFrameWindow ) |
| { |
| pFrameWindow = ImplGetFrameWindow(); |
| } |
| // if( ! ( GetType() == WINDOW_FIXEDTEXT || |
| if( !( GetType() == WINDOW_FIXEDLINE || |
| GetType() == WINDOW_GROUPBOX ) ) |
| { |
| // search for a control that makes member of this window |
| // it is considered the last fixed line or group box |
| // that comes before this control; with the exception of push buttons |
| // which are labeled only if the fixed line or group box |
| // is directly before the control |
| // get form start and form end and index of this control |
| sal_uInt16 nIndex, nFormStart, nFormEnd; |
| Window* pSWindow = ::ImplFindDlgCtrlWindow( pFrameWindow, |
| const_cast<Window*>(this), |
| nIndex, |
| nFormStart, |
| nFormEnd ); |
| if( pSWindow && nIndex != nFormStart ) |
| { |
| if( GetType() == WINDOW_PUSHBUTTON || |
| GetType() == WINDOW_HELPBUTTON || |
| GetType() == WINDOW_OKBUTTON || |
| GetType() == WINDOW_CANCELBUTTON ) |
| { |
| nFormStart = nIndex-1; |
| } |
| for( sal_uInt16 nSearchIndex = nIndex-1; nSearchIndex >= nFormStart; nSearchIndex-- ) |
| { |
| sal_uInt16 nFoundIndex = 0; |
| pSWindow = ::ImplGetChildWindow( pFrameWindow, |
| nSearchIndex, |
| nFoundIndex, |
| sal_False ); |
| if( pSWindow && pSWindow->IsVisible() && |
| ( pSWindow->GetType() == WINDOW_FIXEDLINE || |
| pSWindow->GetType() == WINDOW_GROUPBOX ) ) |
| { |
| pWindow = pSWindow; |
| break; |
| } |
| if( nFoundIndex > nSearchIndex || nSearchIndex == 0 ) |
| break; |
| } |
| } |
| } |
| return pWindow; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| KeyEvent Window::GetActivationKey() const |
| { |
| KeyEvent aKeyEvent; |
| |
| sal_Unicode nAccel = getAccel( GetText() ); |
| if( ! nAccel ) |
| { |
| Window* pWindow = GetAccessibleRelationLabeledBy(); |
| if( pWindow ) |
| nAccel = getAccel( pWindow->GetText() ); |
| } |
| if( nAccel ) |
| { |
| sal_uInt16 nCode = 0; |
| if( nAccel >= 'a' && nAccel <= 'z' ) |
| nCode = KEY_A + (nAccel-'a'); |
| else if( nAccel >= 'A' && nAccel <= 'Z' ) |
| nCode = KEY_A + (nAccel-'A'); |
| else if( nAccel >= '0' && nAccel <= '9' ) |
| nCode = KEY_0 + (nAccel-'0'); |
| else if( nAccel == '.' ) |
| nCode = KEY_POINT; |
| else if( nAccel == '-' ) |
| nCode = KEY_SUBTRACT; |
| KeyCode aKeyCode( nCode, sal_False, sal_False, sal_True, sal_False ); |
| aKeyEvent = KeyEvent( nAccel, aKeyCode ); |
| } |
| return aKeyEvent; |
| } |
