/************************************************************** * * 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 #include #include #include #include #include #include #include #include #include #include #include #ifdef DBG_UTIL #include #endif #include // ======================================================================= #ifdef DBG_UTIL static ByteString ImplGetDialogText( Dialog* pDialog ) { ByteString aErrorStr( pDialog->GetText(), RTL_TEXTENCODING_UTF8 ); if ( (pDialog->GetType() == WINDOW_MESSBOX) || (pDialog->GetType() == WINDOW_INFOBOX) || (pDialog->GetType() == WINDOW_WARNINGBOX) || (pDialog->GetType() == WINDOW_ERRORBOX) || (pDialog->GetType() == WINDOW_QUERYBOX) ) { aErrorStr += ", "; aErrorStr += ByteString( ((MessBox*)pDialog)->GetMessText(), RTL_TEXTENCODING_UTF8 ); } return aErrorStr; } #endif // ======================================================================= static sal_Bool ImplIsMnemonicCtrl( Window* pWindow ) { if( ! pWindow->GetSettings().GetStyleSettings().GetAutoMnemonic() ) return sal_False; if ( (pWindow->GetType() == WINDOW_RADIOBUTTON) || (pWindow->GetType() == WINDOW_CHECKBOX) || (pWindow->GetType() == WINDOW_TRISTATEBOX) || (pWindow->GetType() == WINDOW_PUSHBUTTON) ) return sal_True; if ( pWindow->GetType() == WINDOW_FIXEDTEXT ) { if ( pWindow->GetStyle() & (WB_INFO | WB_NOLABEL) ) return sal_False; Window* pNextWindow = pWindow->GetWindow( WINDOW_NEXT ); if ( !pNextWindow ) return sal_False; pNextWindow = pNextWindow->GetWindow( WINDOW_CLIENT ); if ( !(pNextWindow->GetStyle() & WB_TABSTOP) || (pNextWindow->GetType() == WINDOW_FIXEDTEXT) || (pNextWindow->GetType() == WINDOW_GROUPBOX) || (pNextWindow->GetType() == WINDOW_RADIOBUTTON) || (pNextWindow->GetType() == WINDOW_CHECKBOX) || (pNextWindow->GetType() == WINDOW_TRISTATEBOX) || (pNextWindow->GetType() == WINDOW_PUSHBUTTON) ) return sal_False; return sal_True; } return sal_False; } // ----------------------------------------------------------------------- void ImplWindowAutoMnemonic( Window* pWindow ) { MnemonicGenerator aMnemonicGenerator; Window* pGetChild; Window* pChild; // Die schon vergebenen Mnemonics registieren pGetChild = pWindow->GetWindow( WINDOW_FIRSTCHILD ); while ( pGetChild ) { pChild = pGetChild->ImplGetWindow(); aMnemonicGenerator.RegisterMnemonic( pChild->GetText() ); pGetChild = pGetChild->GetWindow( WINDOW_NEXT ); } // Bei TabPages auch noch die Controls vom Dialog beruecksichtigen if ( pWindow->GetType() == WINDOW_TABPAGE ) { Window* pParent = pWindow->GetParent(); if ( pParent->GetType() == WINDOW_TABCONTROL ) pParent = pParent->GetParent(); if ( (pParent->GetStyle() & (WB_DIALOGCONTROL | WB_NODIALOGCONTROL)) == WB_DIALOGCONTROL ) { pGetChild = pParent->GetWindow( WINDOW_FIRSTCHILD ); while ( pGetChild ) { pChild = pGetChild->ImplGetWindow(); aMnemonicGenerator.RegisterMnemonic( pChild->GetText() ); pGetChild = pGetChild->GetWindow( WINDOW_NEXT ); } } } // Die Mnemonics an die Controls vergeben, die noch keinen haben pGetChild = pWindow->GetWindow( WINDOW_FIRSTCHILD ); while ( pGetChild ) { pChild = pGetChild->ImplGetWindow(); if ( ImplIsMnemonicCtrl( pChild ) ) { XubString aText = pChild->GetText(); if ( aMnemonicGenerator.CreateMnemonic( aText ) ) pChild->SetText( aText ); } pGetChild = pGetChild->GetWindow( WINDOW_NEXT ); } } // ======================================================================= static PushButton* ImplGetDefaultButton( Dialog* pDialog ) { Window* pChild = pDialog->GetWindow( WINDOW_FIRSTCHILD ); while ( pChild ) { if ( pChild->ImplIsPushButton() ) { PushButton* pPushButton = (PushButton*)pChild; if ( pPushButton->ImplIsDefButton() ) return pPushButton; } pChild = pChild->GetWindow( WINDOW_NEXT ); } return NULL; } // ----------------------------------------------------------------------- static PushButton* ImplGetOKButton( Dialog* pDialog ) { Window* pChild = pDialog->GetWindow( WINDOW_FIRSTCHILD ); while ( pChild ) { if ( pChild->GetType() == WINDOW_OKBUTTON ) return (PushButton*)pChild; pChild = pChild->GetWindow( WINDOW_NEXT ); } return NULL; } // ----------------------------------------------------------------------- static PushButton* ImplGetCancelButton( Dialog* pDialog ) { Window* pChild = pDialog->GetWindow( WINDOW_FIRSTCHILD ); while ( pChild ) { if ( pChild->GetType() == WINDOW_CANCELBUTTON ) return (PushButton*)pChild; pChild = pChild->GetWindow( WINDOW_NEXT ); } return NULL; } // ----------------------------------------------------------------------- static void ImplMouseAutoPos( Dialog* pDialog ) { sal_uLong nMouseOptions = pDialog->GetSettings().GetMouseSettings().GetOptions(); if ( nMouseOptions & MOUSE_OPTION_AUTOCENTERPOS ) { Size aSize = pDialog->GetOutputSizePixel(); pDialog->SetPointerPosPixel( Point( aSize.Width()/2, aSize.Height()/2 ) ); } else if ( nMouseOptions & MOUSE_OPTION_AUTODEFBTNPOS ) { Window* pWindow = ImplGetDefaultButton( pDialog ); if ( !pWindow ) pWindow = ImplGetOKButton( pDialog ); if ( !pWindow ) pWindow = ImplGetCancelButton( pDialog ); if ( !pWindow ) pWindow = pDialog; Size aSize = pWindow->GetOutputSizePixel(); pWindow->SetPointerPosPixel( Point( aSize.Width()/2, aSize.Height()/2 ) ); } } // ======================================================================= struct DialogImpl { long mnResult; bool mbStartedModal; Link maEndDialogHdl; DialogImpl() : mnResult( -1 ), mbStartedModal( false ) {} }; // ======================================================================= void Dialog::ImplInitDialogData() { mpWindowImpl->mbDialog = sal_True; mpDialogParent = NULL; mpPrevExecuteDlg = NULL; mbInExecute = sal_False; mbOldSaveBack = sal_False; mbInClose = sal_False; mbModalMode = sal_False; mnMousePositioned = 0; mpDialogImpl = new DialogImpl; } // ----------------------------------------------------------------------- void Dialog::ImplInit( Window* pParent, WinBits nStyle ) { sal_uInt16 nSysWinMode = Application::GetSystemWindowMode(); if ( !(nStyle & WB_NODIALOGCONTROL) ) nStyle |= WB_DIALOGCONTROL; nStyle |= WB_ROLLABLE; // Now, all Dialogs are per default system windows !!! nStyle |= WB_SYSTEMWINDOW; // parent is NULL: get the default Dialog parent if ( !pParent ) { pParent = Application::GetDefDialogParent(); if ( !pParent && !(nStyle & WB_SYSTEMWINDOW) ) pParent = ImplGetSVData()->maWinData.mpAppWin; // If Parent is disabled, then we search for a modal dialog // in this frame if ( pParent && (!pParent->IsInputEnabled() || pParent->IsInModalMode()) ) { ImplSVData* pSVData = ImplGetSVData(); Dialog* pExeDlg = pSVData->maWinData.mpLastExecuteDlg; while ( pExeDlg ) { // Nur wenn er sichtbar und enabled ist if ( pParent->ImplGetFirstOverlapWindow()->IsWindowOrChild( pExeDlg, sal_True ) && pExeDlg->IsReallyVisible() && pExeDlg->IsEnabled() && pExeDlg->IsInputEnabled() && !pExeDlg->IsInModalMode() ) { pParent = pExeDlg; break; } pExeDlg = pExeDlg->mpPrevExecuteDlg; } } } // DIALOG_NO_PARENT: explicitly don't have a parent for this Dialog else if( pParent == DIALOG_NO_PARENT ) pParent = NULL; /* // Now, all Dialogs are per default system windows !!! if ( pParent && !(nSysWinMode & SYSTEMWINDOW_MODE_NOAUTOMODE) ) { if ( !pParent->mpWindowImpl->mpFrameWindow->IsVisible() ) pParent = NULL; else { if ( pParent->mpWindowImpl->mpFrameWindow->IsDialog() ) { Size aOutSize = pParent->mpWindowImpl->mpFrameWindow->GetOutputSizePixel(); if ( (aOutSize.Width() < 210) ||(aOutSize.Height() < 160) ) nStyle |= WB_SYSTEMWINDOW; } } } */ if ( !pParent || (nStyle & WB_SYSTEMWINDOW) || (pParent->mpWindowImpl->mpFrameData->mbNeedSysWindow && !(nSysWinMode & SYSTEMWINDOW_MODE_NOAUTOMODE)) || (nSysWinMode & SYSTEMWINDOW_MODE_DIALOG) ) { // create window with a small border ? if ( (nStyle & (WB_BORDER | WB_NOBORDER | WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE)) == WB_BORDER ) { ImplBorderWindow* pBorderWin = new ImplBorderWindow( pParent, nStyle, BORDERWINDOW_STYLE_FRAME ); SystemWindow::ImplInit( pBorderWin, nStyle & ~WB_BORDER, NULL ); pBorderWin->mpWindowImpl->mpClientWindow = this; pBorderWin->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder ); mpWindowImpl->mpBorderWindow = pBorderWin; mpWindowImpl->mpRealParent = pParent; } else { mpWindowImpl->mbFrame = sal_True; mpWindowImpl->mbOverlapWin = sal_True; SystemWindow::ImplInit( pParent, (nStyle & (WB_MOVEABLE | WB_SIZEABLE | WB_ROLLABLE | WB_CLOSEABLE | WB_STANDALONE)) | WB_CLOSEABLE, NULL ); // Now set all style bits mpWindowImpl->mnStyle = nStyle; } } else { ImplBorderWindow* pBorderWin = new ImplBorderWindow( pParent, nStyle, BORDERWINDOW_STYLE_OVERLAP | BORDERWINDOW_STYLE_BORDER ); SystemWindow::ImplInit( pBorderWin, nStyle & ~WB_BORDER, NULL ); pBorderWin->mpWindowImpl->mpClientWindow = this; pBorderWin->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder ); mpWindowImpl->mpBorderWindow = pBorderWin; mpWindowImpl->mpRealParent = pParent; } SetActivateMode( ACTIVATE_MODE_GRABFOCUS ); ImplInitSettings(); } // ----------------------------------------------------------------------- void Dialog::ImplInitSettings() { // user override if ( IsControlBackground() ) SetBackground( GetControlBackground() ); // NWF background else if( IsNativeControlSupported( CTRL_WINDOW_BACKGROUND, PART_BACKGROUND_DIALOG ) ) { mpWindowImpl->mnNativeBackground = PART_BACKGROUND_DIALOG; EnableChildTransparentMode( sal_True ); } // fallback to settings color else SetBackground( GetSettings().GetStyleSettings().GetDialogColor() ); } // ----------------------------------------------------------------------- void Dialog::ImplCenterDialog() { Rectangle aDeskRect = ImplGetFrameWindow()->GetDesktopRectPixel(); Point aDeskPos = aDeskRect.TopLeft(); Size aDeskSize = aDeskRect.GetSize(); Size aWinSize = GetSizePixel(); Window *pWindow = this; while ( pWindow->mpWindowImpl->mpBorderWindow ) pWindow = pWindow->mpWindowImpl->mpBorderWindow; Point aWinPos( ((aDeskSize.Width() - aWinSize.Width()) / 2) + aDeskPos.X(), ((aDeskSize.Height() - aWinSize.Height()) / 2) + aDeskPos.Y() ); // Pruefen, ob Dialogbox ausserhalb des Desks liegt if ( (aWinPos.X() + aWinSize.Width()) > (aDeskPos.X()+aDeskSize.Width()) ) aWinPos.X() = aDeskPos.X()+aDeskSize.Width() - aWinSize.Width(); if ( (aWinPos.Y()+aWinSize.Height()) > (aDeskPos.Y()+aDeskSize.Height()) ) aWinPos.Y() = aDeskPos.Y()+aDeskSize.Height() - aWinSize.Height(); // Linke Ecke bevorzugen, da Titelbar oben ist if ( aWinPos.X() < aDeskPos.X() ) aWinPos.X() = aDeskPos.X(); if ( aWinPos.Y() < aDeskPos.Y() ) aWinPos.Y() = aDeskPos.Y(); //SetPosPixel( aWinPos ); SetPosPixel( pWindow->ScreenToOutputPixel( aWinPos ) ); } // ----------------------------------------------------------------------- Dialog::Dialog( WindowType nType ) : SystemWindow( nType ) { ImplInitDialogData(); } // ----------------------------------------------------------------------- Dialog::Dialog( Window* pParent, WinBits nStyle ) : SystemWindow( WINDOW_DIALOG ) { ImplInitDialogData(); ImplInit( pParent, nStyle ); } // ----------------------------------------------------------------------- Dialog::Dialog( Window* pParent, const ResId& rResId ) : SystemWindow( WINDOW_DIALOG ) { ImplInitDialogData(); rResId.SetRT( RSC_DIALOG ); ImplInit( pParent, ImplInitRes( rResId ) ); ImplLoadRes( rResId ); } // ----------------------------------------------------------------------- Dialog::~Dialog() { delete mpDialogImpl; mpDialogImpl = NULL; } // ----------------------------------------------------------------------- IMPL_LINK( Dialog, ImplAsyncCloseHdl, void*, EMPTYARG ) { Close(); return 0; } // ----------------------------------------------------------------------- long Dialog::Notify( NotifyEvent& rNEvt ) { // Zuerst Basisklasse rufen wegen TabSteuerung long nRet = SystemWindow::Notify( rNEvt ); if ( !nRet ) { if ( rNEvt.GetType() == EVENT_KEYINPUT ) { const KeyEvent* pKEvt = rNEvt.GetKeyEvent(); KeyCode aKeyCode = pKEvt->GetKeyCode(); sal_uInt16 nKeyCode = aKeyCode.GetCode(); if ( (nKeyCode == KEY_ESCAPE) && ((GetStyle() & WB_CLOSEABLE) || ImplGetCancelButton( this ) || ImplGetOKButton( this )) ) { // #i89505# for the benefit of slightly mentally challenged implementations // like e.g. SfxModelessDialog which destroy themselves inside Close() // post this Close asynchronous so we can leave our key handler before // we get destroyed PostUserEvent( LINK( this, Dialog, ImplAsyncCloseHdl ), this ); return sal_True; } } else if ( rNEvt.GetType() == EVENT_GETFOCUS ) { // make sure the dialog is still modal // changing focus between application frames may // have re-enabled input for our parent if( mbInExecute && mbModalMode ) { // do not change modal counter (pSVData->maAppData.mnModalDialog) SetModalInputMode( sal_False ); SetModalInputMode( sal_True ); // #93022# def-button might have changed after show if( !mnMousePositioned ) { mnMousePositioned = 1; ImplMouseAutoPos( this ); } } } } return nRet; } // ----------------------------------------------------------------------- void Dialog::StateChanged( StateChangedType nType ) { SystemWindow::StateChanged( nType ); if ( nType == STATE_CHANGE_INITSHOW ) { if ( GetSettings().GetStyleSettings().GetAutoMnemonic() ) ImplWindowAutoMnemonic( this ); //if ( IsDefaultPos() && !mpWindowImpl->mbFrame ) // ImplCenterDialog(); if ( !HasChildPathFocus() || HasFocus() ) GrabFocusToFirstControl(); if ( !(GetStyle() & WB_CLOSEABLE) ) { if ( ImplGetCancelButton( this ) || ImplGetOKButton( this ) ) { if ( ImplGetBorderWindow() ) ((ImplBorderWindow*)ImplGetBorderWindow())->SetCloser(); } } ImplMouseAutoPos( this ); } else if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) { ImplInitSettings(); Invalidate(); } } // ----------------------------------------------------------------------- void Dialog::DataChanged( const DataChangedEvent& rDCEvt ) { SystemWindow::DataChanged( rDCEvt ); if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && (rDCEvt.GetFlags() & SETTINGS_STYLE) ) { ImplInitSettings(); Invalidate(); } } // ----------------------------------------------------------------------- sal_Bool Dialog::Close() { ImplDelData aDelData; ImplAddDel( &aDelData ); ImplCallEventListeners( VCLEVENT_WINDOW_CLOSE ); if ( aDelData.IsDelete() ) return sal_False; ImplRemoveDel( &aDelData ); if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() && !IsInExecute() ) return sal_False; mbInClose = sal_True; if ( !(GetStyle() & WB_CLOSEABLE) ) { sal_Bool bRet = sal_True; ImplAddDel( &aDelData ); PushButton* pButton = ImplGetCancelButton( this ); if ( pButton ) pButton->Click(); else { pButton = ImplGetOKButton( this ); if ( pButton ) pButton->Click(); else bRet = sal_False; } if ( aDelData.IsDelete() ) return sal_True; ImplRemoveDel( &aDelData ); return bRet; } if ( IsInExecute() ) { EndDialog( sal_False ); mbInClose = sal_False; return sal_True; } else { mbInClose = sal_False; return SystemWindow::Close(); } } // ----------------------------------------------------------------------- sal_Bool Dialog::ImplStartExecuteModal() { if ( mbInExecute ) { #ifdef DBG_UTIL ByteString aErrorStr( "Dialog::StartExecuteModal() is called in Dialog::StartExecuteModal(): " ); aErrorStr += ImplGetDialogText( this ); DBG_ERROR( aErrorStr.GetBuffer() ); #endif return sal_False; } if ( Application::IsDialogCancelEnabled() ) { #ifdef DBG_UTIL ByteString aErrorStr( "Dialog::StartExecuteModal() is called in a none UI application: " ); aErrorStr += ImplGetDialogText( this ); DBG_ERROR( aErrorStr.GetBuffer() ); #endif return sal_False; } #ifdef DBG_UTIL Window* pParent = GetParent(); if ( pParent ) { pParent = pParent->ImplGetFirstOverlapWindow(); DBG_ASSERT( pParent->IsReallyVisible(), "Dialog::StartExecuteModal() - Parent not visible" ); DBG_ASSERT( pParent->IsInputEnabled(), "Dialog::StartExecuteModal() - Parent input disabled, use another parent to ensure modality!" ); DBG_ASSERT( ! pParent->IsInModalMode(), "Dialog::StartExecuteModal() - Parent already modally disabled, use another parent to ensure modality!" ); } #endif ImplSVData* pSVData = ImplGetSVData(); // Dialoge, die sich in Execute befinden, miteinander verketten mpPrevExecuteDlg = pSVData->maWinData.mpLastExecuteDlg; pSVData->maWinData.mpLastExecuteDlg = this; // Capture beenden, damit der Dialog bedient werden kann if ( pSVData->maWinData.mpTrackWin ) pSVData->maWinData.mpTrackWin->EndTracking( ENDTRACK_CANCEL ); if ( pSVData->maWinData.mpCaptureWin ) pSVData->maWinData.mpCaptureWin->ReleaseMouse(); EnableInput( sal_True, sal_True ); if ( GetParent() ) { NotifyEvent aNEvt( EVENT_EXECUTEDIALOG, this ); GetParent()->Notify( aNEvt ); } mbInExecute = sal_True; SetModalInputMode( sal_True ); mbOldSaveBack = IsSaveBackgroundEnabled(); EnableSaveBackground(); // FIXME: no layouting, workaround some clipping issues ImplAdjustNWFSizes(); Show(); pSVData->maAppData.mnModalMode++; return sal_True; } // ----------------------------------------------------------------------- void Dialog::ImplEndExecuteModal() { ImplSVData* pSVData = ImplGetSVData(); pSVData->maAppData.mnModalMode--; } // ----------------------------------------------------------------------- short Dialog::Execute() { if ( !ImplStartExecuteModal() ) return 0; ImplDelData aDelData; ImplAddDel( &aDelData ); #ifdef DBG_UTIL ImplDelData aParentDelData; Window* pDialogParent = mpDialogParent; if( pDialogParent ) pDialogParent->ImplAddDel( &aParentDelData ); #endif // Yield util EndDialog is called or dialog gets destroyed // (the latter should not happen, but better safe than sorry while ( !aDelData.IsDelete() && mbInExecute ) Application::Yield(); ImplEndExecuteModal(); #ifdef DBG_UTIL if( pDialogParent ) { if( ! aParentDelData.IsDelete() ) pDialogParent->ImplRemoveDel( &aParentDelData ); else DBG_ERROR( "Dialog::Execute() - Parent of dialog destroyed in Execute()" ); } #endif if ( !aDelData.IsDelete() ) ImplRemoveDel( &aDelData ); #ifdef DBG_UTIL else { DBG_ERROR( "Dialog::Execute() - Dialog destroyed in Execute()" ); } #endif long nRet = mpDialogImpl->mnResult; mpDialogImpl->mnResult = -1; return (short)nRet; } // ----------------------------------------------------------------------- // virtual void Dialog::StartExecuteModal( const Link& rEndDialogHdl ) { if ( !ImplStartExecuteModal() ) return; mpDialogImpl->maEndDialogHdl = rEndDialogHdl; mpDialogImpl->mbStartedModal = true; } // ----------------------------------------------------------------------- sal_Bool Dialog::IsStartedModal() const { return mpDialogImpl->mbStartedModal; } // ----------------------------------------------------------------------- void Dialog::EndDialog( long nResult ) { if ( mbInExecute ) { SetModalInputMode( sal_False ); // Dialog aus der Kette der Dialoge die in Execute stehen entfernen ImplSVData* pSVData = ImplGetSVData(); Dialog* pExeDlg = pSVData->maWinData.mpLastExecuteDlg; while ( pExeDlg ) { if ( pExeDlg == this ) { pSVData->maWinData.mpLastExecuteDlg = mpPrevExecuteDlg; break; } pExeDlg = pExeDlg->mpPrevExecuteDlg; } // set focus to previous modal dialogue if it is modal for // the same frame parent (or NULL) if( mpPrevExecuteDlg ) { Window* pFrameParent = ImplGetFrameWindow()->ImplGetParent(); Window* pPrevFrameParent = mpPrevExecuteDlg->ImplGetFrameWindow()->ImplGetParent(); if( ( !pFrameParent && !pPrevFrameParent ) || ( pFrameParent && pPrevFrameParent && pFrameParent->ImplGetFrame() == pPrevFrameParent->ImplGetFrame() ) ) { mpPrevExecuteDlg->GrabFocus(); } } mpPrevExecuteDlg = NULL; Hide(); EnableSaveBackground( mbOldSaveBack ); if ( GetParent() ) { NotifyEvent aNEvt( EVENT_ENDEXECUTEDIALOG, this ); GetParent()->Notify( aNEvt ); } mpDialogImpl->mnResult = nResult; if ( mpDialogImpl->mbStartedModal ) { ImplEndExecuteModal(); mpDialogImpl->maEndDialogHdl.Call( this ); mpDialogImpl->maEndDialogHdl = Link(); mpDialogImpl->mbStartedModal = false; mpDialogImpl->mnResult = -1; } mbInExecute = sal_False; } } // ----------------------------------------------------------------------- long Dialog::GetResult() const { return mpDialogImpl->mnResult; } // ----------------------------------------------------------------------- void Dialog::EndAllDialogs( Window* pParent ) { ImplSVData* pSVData = ImplGetSVData(); Dialog* pTempModDialog; Dialog* pModDialog = pSVData->maWinData.mpLastExecuteDlg; while ( pModDialog ) { pTempModDialog = pModDialog->mpPrevExecuteDlg; if( !pParent || ( pParent && pParent->IsWindowOrChild( pModDialog, sal_True ) ) ) { pModDialog->EndDialog( sal_False ); pModDialog->PostUserEvent( Link() ); } pModDialog = pTempModDialog; } } // ----------------------------------------------------------------------- void Dialog::SetModalInputMode( sal_Bool bModal ) { if ( bModal == mbModalMode ) return; ImplSVData* pSVData = ImplGetSVData(); mbModalMode = bModal; if ( bModal ) { pSVData->maAppData.mnModalDialog++; // Diable the prev Modal Dialog, because our dialog must close at first, // before the other dialog can be closed (because the other dialog // is on stack since our dialog returns) if ( mpPrevExecuteDlg && !mpPrevExecuteDlg->IsWindowOrChild( this, sal_True ) ) mpPrevExecuteDlg->EnableInput( sal_False, sal_True, sal_True, this ); // determine next overlap dialog parent Window* pParent = GetParent(); if ( pParent ) { // #103716# dialogs should always be modal to the whole frame window // #115933# disable the whole frame hierarchie, useful if our parent // is a modeless dialog mpDialogParent = pParent->mpWindowImpl->mpFrameWindow; mpDialogParent->ImplIncModalCount(); } } else { pSVData->maAppData.mnModalDialog--; if ( mpDialogParent ) { // #115933# re-enable the whole frame hierarchie again (see above) // note that code in getfocus assures that we do not accidentally enable // windows that were disabled before mpDialogParent->ImplDecModalCount(); } // Enable the prev Modal Dialog if ( mpPrevExecuteDlg && !mpPrevExecuteDlg->IsWindowOrChild( this, sal_True ) ) { mpPrevExecuteDlg->EnableInput( sal_True, sal_True, sal_True, this ); // ensure continued modality of prev dialog // do not change modality counter // #i119994# need find the last modal dialog before reactive it Dialog * pPrevModalDlg = mpPrevExecuteDlg; while( pPrevModalDlg && !pPrevModalDlg->IsModalInputMode() ) pPrevModalDlg = pPrevModalDlg->mpPrevExecuteDlg; if( pPrevModalDlg && ( pPrevModalDlg == mpPrevExecuteDlg || !pPrevModalDlg->IsWindowOrChild( this, sal_True ) ) ) { mpPrevExecuteDlg->SetModalInputMode( sal_False ); mpPrevExecuteDlg->SetModalInputMode( sal_True ); } } } } // ----------------------------------------------------------------------- void Dialog::SetModalInputMode( sal_Bool bModal, sal_Bool bSubModalDialogs ) { if ( bSubModalDialogs ) { Window* pOverlap = ImplGetFirstOverlapWindow(); pOverlap = pOverlap->mpWindowImpl->mpFirstOverlap; while ( pOverlap ) { if ( pOverlap->IsDialog() ) ((Dialog*)pOverlap)->SetModalInputMode( bModal, sal_True ); pOverlap = pOverlap->mpWindowImpl->mpNext; } } SetModalInputMode( bModal ); } // ----------------------------------------------------------------------- void Dialog::GrabFocusToFirstControl() { Window* pFocusControl; // Wenn Dialog den Focus hat, versuchen wr trotzdem // ein Focus-Control zu finden if ( HasFocus() ) pFocusControl = NULL; else { // Wenn schon ein Child-Fenster mal den Focus hatte, // dann dieses bevorzugen pFocusControl = ImplGetFirstOverlapWindow()->mpWindowImpl->mpLastFocusWindow; // Control aus der Dialog-Steuerung suchen if ( pFocusControl ) pFocusControl = ImplFindDlgCtrlWindow( pFocusControl ); } // Kein Control hatte vorher den Focus, oder das Control // befindet sich nicht in der Tab-Steuerung, dann das erste // Control in der TabSteuerung den Focus geben if ( !pFocusControl || !(pFocusControl->GetStyle() & WB_TABSTOP) || !pFocusControl->IsVisible() || !pFocusControl->IsEnabled() || !pFocusControl->IsInputEnabled() ) { sal_uInt16 n = 0; pFocusControl = ImplGetDlgWindow( n, DLGWINDOW_FIRST ); } if ( pFocusControl ) pFocusControl->ImplControlFocus( GETFOCUS_INIT ); } void Dialog::GetDrawWindowBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder, sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const { ImplBorderWindow aImplWin( (Window*)this, WB_BORDER|WB_STDWORK, BORDERWINDOW_STYLE_OVERLAP ); // aImplWin.SetText( GetText() ); // aImplWin.SetPosSizePixel( aPos.X(), aPos.Y(), aSize.Width(), aSize.Height() ); // aImplWin.SetDisplayActive( sal_True ); // aImplWin.InitView(); aImplWin.GetBorder( rLeftBorder, rTopBorder, rRightBorder, rBottomBorder ); } void Dialog::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, sal_uLong ) { Point aPos = pDev->LogicToPixel( rPos ); Size aSize = pDev->LogicToPixel( rSize ); Wallpaper aWallpaper = GetBackground(); if ( !aWallpaper.IsBitmap() ) ImplInitSettings(); pDev->Push(); pDev->SetMapMode(); pDev->SetLineColor(); if ( aWallpaper.IsBitmap() ) pDev->DrawBitmapEx( aPos, aSize, aWallpaper.GetBitmap() ); else { pDev->SetFillColor( aWallpaper.GetColor() ); pDev->DrawRect( Rectangle( aPos, aSize ) ); } if (!( GetStyle() & WB_NOBORDER )) { ImplBorderWindow aImplWin( this, WB_BORDER|WB_STDWORK, BORDERWINDOW_STYLE_OVERLAP ); aImplWin.SetText( GetText() ); aImplWin.SetPosSizePixel( aPos.X(), aPos.Y(), aSize.Width(), aSize.Height() ); aImplWin.SetDisplayActive( sal_True ); aImplWin.InitView(); aImplWin.Draw( Rectangle( aPos, aSize ), pDev, aPos ); } pDev->Pop(); } // ======================================================================= ModelessDialog::ModelessDialog( Window* pParent, WinBits nStyle ) : Dialog( WINDOW_MODELESSDIALOG ) { ImplInit( pParent, nStyle ); } // ----------------------------------------------------------------------- ModelessDialog::ModelessDialog( Window* pParent, const ResId& rResId ) : Dialog( WINDOW_MODELESSDIALOG ) { rResId.SetRT( RSC_MODELESSDIALOG ); WinBits nStyle = ImplInitRes( rResId ); ImplInit( pParent, nStyle ); ImplLoadRes( rResId ); if ( !(nStyle & WB_HIDE) ) Show(); } // ======================================================================= ModalDialog::ModalDialog( Window* pParent, WinBits nStyle ) : Dialog( WINDOW_MODALDIALOG ) { ImplInit( pParent, nStyle ); } // ----------------------------------------------------------------------- ModalDialog::ModalDialog( Window* pParent, const ResId& rResId ) : Dialog( WINDOW_MODALDIALOG ) { rResId.SetRT( RSC_MODALDIALOG ); ImplInit( pParent, ImplInitRes( rResId ) ); ImplLoadRes( rResId ); }