Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <config_features.h>
21 :
22 : #include <com/sun/star/beans/XPropertySet.hpp>
23 : #include <com/sun/star/util/thePathSettings.hpp>
24 : #include <comphelper/processfactory.hxx>
25 : #include <osl/file.hxx>
26 :
27 : #include <tools/debug.hxx>
28 :
29 : #include <tools/rc.h>
30 : #include <svdata.hxx>
31 : #include <window.h>
32 : #include <brdwin.hxx>
33 :
34 : #include <rtl/strbuf.hxx>
35 : #include <sal/log.hxx>
36 :
37 : #include <vcl/builder.hxx>
38 : #include <vcl/layout.hxx>
39 : #include <vcl/svapp.hxx>
40 : #include <vcl/event.hxx>
41 : #include <vcl/wrkwin.hxx>
42 : #include <vcl/button.hxx>
43 : #include <vcl/mnemonic.hxx>
44 : #include <vcl/dialog.hxx>
45 : #include <vcl/decoview.hxx>
46 : #include <vcl/msgbox.hxx>
47 : #include <vcl/unowrap.hxx>
48 : #include <vcl/settings.hxx>
49 :
50 : #include <iostream>
51 :
52 0 : static OString ImplGetDialogText( Dialog* pDialog )
53 : {
54 : OStringBuffer aErrorStr(OUStringToOString(
55 0 : pDialog->GetText(), RTL_TEXTENCODING_UTF8));
56 :
57 0 : OUString sMessage;
58 0 : if (MessBox* pMessBox = dynamic_cast<MessBox*>(pDialog))
59 : {
60 0 : sMessage = pMessBox->GetMessText();
61 : }
62 0 : else if (MessageDialog* pMessDialog = dynamic_cast<MessageDialog*>(pDialog))
63 : {
64 0 : sMessage = pMessDialog->get_primary_text();
65 : }
66 :
67 0 : if (!sMessage.isEmpty())
68 : {
69 0 : aErrorStr.append(", ");
70 : aErrorStr.append(OUStringToOString(
71 0 : sMessage, RTL_TEXTENCODING_UTF8));
72 : }
73 0 : return aErrorStr.makeStringAndClear();
74 : }
75 :
76 15669 : static bool ImplIsMnemonicCtrl( vcl::Window* pWindow )
77 : {
78 15669 : if( ! pWindow->GetSettings().GetStyleSettings().GetAutoMnemonic() )
79 0 : return false;
80 :
81 47007 : if ( (pWindow->GetType() == WINDOW_RADIOBUTTON) ||
82 31338 : (pWindow->GetType() == WINDOW_CHECKBOX) ||
83 47007 : (pWindow->GetType() == WINDOW_TRISTATEBOX) ||
84 15669 : (pWindow->GetType() == WINDOW_PUSHBUTTON) )
85 0 : return true;
86 :
87 15669 : if ( pWindow->GetType() == WINDOW_FIXEDTEXT )
88 : {
89 4 : FixedText *pText = static_cast<FixedText*>(pWindow);
90 4 : if (pText->get_mnemonic_widget())
91 0 : return true;
92 : //This is the legacy pre-layout logic which we retain
93 : //until we can be sure we can remove it
94 4 : if ( pWindow->GetStyle() & (WB_INFO | WB_NOLABEL) )
95 0 : return false;
96 4 : vcl::Window* pNextWindow = pWindow->GetWindow( GetWindowType::Next );
97 4 : if ( !pNextWindow )
98 2 : return false;
99 2 : pNextWindow = pNextWindow->GetWindow( GetWindowType::Client );
100 5 : if ( !(pNextWindow->GetStyle() & WB_TABSTOP) ||
101 2 : (pNextWindow->GetType() == WINDOW_FIXEDTEXT) ||
102 2 : (pNextWindow->GetType() == WINDOW_GROUPBOX) ||
103 2 : (pNextWindow->GetType() == WINDOW_RADIOBUTTON) ||
104 2 : (pNextWindow->GetType() == WINDOW_CHECKBOX) ||
105 4 : (pNextWindow->GetType() == WINDOW_TRISTATEBOX) ||
106 1 : (pNextWindow->GetType() == WINDOW_PUSHBUTTON) )
107 1 : return false;
108 :
109 1 : return true;
110 : }
111 :
112 15665 : return false;
113 : }
114 :
115 : // Called by native error dialog popup implementations
116 0 : void ImplHideSplash()
117 : {
118 0 : ImplSVData* pSVData = ImplGetSVData();
119 0 : if( pSVData->mpIntroWindow )
120 0 : pSVData->mpIntroWindow->Hide();
121 0 : }
122 :
123 : //Get next window after pChild of a pTopLevel window as
124 : //if any intermediate layout widgets didn't exist
125 121040 : vcl::Window * nextLogicalChildOfParent(vcl::Window *pTopLevel, vcl::Window *pChild)
126 : {
127 121040 : vcl::Window *pLastChild = pChild;
128 :
129 121040 : if (isContainerWindow(*pChild))
130 764 : pChild = pChild->GetWindow(GetWindowType::FirstChild);
131 : else
132 120276 : pChild = pChild->GetWindow(GetWindowType::Next);
133 :
134 244368 : while (!pChild)
135 : {
136 38062 : vcl::Window *pParent = pLastChild->GetParent();
137 38062 : if (!pParent)
138 150 : return NULL;
139 37912 : if (pParent == pTopLevel)
140 35624 : return NULL;
141 2288 : pLastChild = pParent;
142 2288 : pChild = pParent->GetWindow(GetWindowType::Next);
143 : }
144 :
145 85266 : if (pChild && isContainerWindow(*pChild))
146 552 : pChild = nextLogicalChildOfParent(pTopLevel, pChild);
147 :
148 85266 : return pChild;
149 : }
150 :
151 0 : vcl::Window * prevLogicalChildOfParent(vcl::Window *pTopLevel, vcl::Window *pChild)
152 : {
153 0 : vcl::Window *pLastChild = pChild;
154 :
155 0 : if (isContainerWindow(*pChild))
156 0 : pChild = pChild->GetWindow(GetWindowType::LastChild);
157 : else
158 0 : pChild = pChild->GetWindow(GetWindowType::Prev);
159 :
160 0 : while (!pChild)
161 : {
162 0 : vcl::Window *pParent = pLastChild->GetParent();
163 0 : if (!pParent)
164 0 : return NULL;
165 0 : if (pParent == pTopLevel)
166 0 : return NULL;
167 0 : pLastChild = pParent;
168 0 : pChild = pParent->GetWindow(GetWindowType::Prev);
169 : }
170 :
171 0 : if (pChild && isContainerWindow(*pChild))
172 0 : pChild = prevLogicalChildOfParent(pTopLevel, pChild);
173 :
174 0 : return pChild;
175 : }
176 :
177 : //Get first window of a pTopLevel window as
178 : //if any intermediate layout widgets didn't exist
179 66749 : vcl::Window * firstLogicalChildOfParent(vcl::Window *pTopLevel)
180 : {
181 66749 : vcl::Window *pChild = pTopLevel->GetWindow(GetWindowType::FirstChild);
182 66749 : if (pChild && isContainerWindow(*pChild))
183 142 : pChild = nextLogicalChildOfParent(pTopLevel, pChild);
184 66749 : return pChild;
185 : }
186 :
187 28914 : void ImplWindowAutoMnemonic( vcl::Window* pWindow )
188 : {
189 28914 : MnemonicGenerator aMnemonicGenerator;
190 : vcl::Window* pGetChild;
191 : vcl::Window* pChild;
192 :
193 : // register the assigned mnemonics
194 28914 : pGetChild = pWindow->GetWindow( GetWindowType::FirstChild );
195 73497 : while ( pGetChild )
196 : {
197 15669 : pChild = pGetChild->ImplGetWindow();
198 15669 : aMnemonicGenerator.RegisterMnemonic( pChild->GetText() );
199 15669 : pGetChild = nextLogicalChildOfParent(pWindow, pGetChild);
200 : }
201 :
202 : // take the Controls of the dialog into account for TabPages
203 28914 : if ( pWindow->GetType() == WINDOW_TABPAGE )
204 : {
205 0 : vcl::Window* pParent = pWindow->GetParent();
206 0 : if ( pParent->GetType() == WINDOW_TABCONTROL )
207 0 : pParent = pParent->GetParent();
208 :
209 0 : if ( (pParent->GetStyle() & (WB_DIALOGCONTROL | WB_NODIALOGCONTROL)) == WB_DIALOGCONTROL )
210 : {
211 0 : pGetChild = pParent->GetWindow( GetWindowType::FirstChild );
212 0 : while ( pGetChild )
213 : {
214 0 : pChild = pGetChild->ImplGetWindow();
215 0 : aMnemonicGenerator.RegisterMnemonic( pChild->GetText() );
216 0 : pGetChild = nextLogicalChildOfParent(pWindow, pGetChild);
217 : }
218 : }
219 : }
220 :
221 : // assign mnemonics to Controls which have none
222 28914 : pGetChild = pWindow->GetWindow( GetWindowType::FirstChild );
223 73497 : while ( pGetChild )
224 : {
225 15669 : pChild = pGetChild->ImplGetWindow();
226 15669 : if ( ImplIsMnemonicCtrl( pChild ) )
227 : {
228 1 : OUString aText = pChild->GetText();
229 2 : OUString aNewText = aMnemonicGenerator.CreateMnemonic( aText );
230 1 : if ( aText != aNewText )
231 2 : pChild->SetText( aNewText );
232 : }
233 :
234 15669 : pGetChild = nextLogicalChildOfParent(pWindow, pGetChild);
235 28914 : }
236 28914 : }
237 :
238 1 : static VclButtonBox* getActionArea(Dialog *pDialog)
239 : {
240 1 : VclButtonBox *pButtonBox = NULL;
241 1 : if (pDialog->isLayoutEnabled())
242 : {
243 1 : vcl::Window *pBox = pDialog->GetWindow(GetWindowType::FirstChild);
244 1 : vcl::Window *pChild = pBox->GetWindow(GetWindowType::LastChild);
245 2 : while (pChild)
246 : {
247 1 : pButtonBox = dynamic_cast<VclButtonBox*>(pChild);
248 1 : if (pButtonBox)
249 1 : break;
250 0 : pChild = pChild->GetWindow(GetWindowType::Prev);
251 : }
252 : }
253 1 : return pButtonBox;
254 : }
255 :
256 0 : static vcl::Window* getActionAreaButtonList(Dialog *pDialog)
257 : {
258 0 : VclButtonBox* pButtonBox = getActionArea(pDialog);
259 0 : if (pButtonBox)
260 0 : return pButtonBox->GetWindow(GetWindowType::FirstChild);
261 0 : return pDialog->GetWindow(GetWindowType::FirstChild);
262 : }
263 :
264 0 : static PushButton* ImplGetDefaultButton( Dialog* pDialog )
265 : {
266 0 : vcl::Window* pChild = getActionAreaButtonList(pDialog);
267 0 : while ( pChild )
268 : {
269 0 : if ( pChild->ImplIsPushButton() )
270 : {
271 0 : PushButton* pPushButton = static_cast<PushButton*>(pChild);
272 0 : if ( pPushButton->ImplIsDefButton() )
273 0 : return pPushButton;
274 : }
275 :
276 0 : pChild = pChild->GetWindow( GetWindowType::Next );
277 : }
278 :
279 0 : return NULL;
280 : }
281 :
282 0 : static PushButton* ImplGetOKButton( Dialog* pDialog )
283 : {
284 0 : vcl::Window* pChild = getActionAreaButtonList(pDialog);
285 0 : while ( pChild )
286 : {
287 0 : if ( pChild->GetType() == WINDOW_OKBUTTON )
288 0 : return static_cast<PushButton*>(pChild);
289 :
290 0 : pChild = pChild->GetWindow( GetWindowType::Next );
291 : }
292 :
293 0 : return NULL;
294 : }
295 :
296 0 : static PushButton* ImplGetCancelButton( Dialog* pDialog )
297 : {
298 0 : vcl::Window* pChild = getActionAreaButtonList(pDialog);
299 :
300 0 : while ( pChild )
301 : {
302 0 : if ( pChild->GetType() == WINDOW_CANCELBUTTON )
303 0 : return static_cast<PushButton*>(pChild);
304 :
305 0 : pChild = pChild->GetWindow( GetWindowType::Next );
306 : }
307 :
308 0 : return NULL;
309 : }
310 :
311 5 : static void ImplMouseAutoPos( Dialog* pDialog )
312 : {
313 5 : MouseSettingsOptions nMouseOptions = pDialog->GetSettings().GetMouseSettings().GetOptions();
314 5 : if ( nMouseOptions & MouseSettingsOptions::AutoCenterPos )
315 : {
316 0 : Size aSize = pDialog->GetOutputSizePixel();
317 0 : pDialog->SetPointerPosPixel( Point( aSize.Width()/2, aSize.Height()/2 ) );
318 : }
319 5 : else if ( nMouseOptions & MouseSettingsOptions::AutoDefBtnPos )
320 : {
321 0 : vcl::Window* pWindow = ImplGetDefaultButton( pDialog );
322 0 : if ( !pWindow )
323 0 : pWindow = ImplGetOKButton( pDialog );
324 0 : if ( !pWindow )
325 0 : pWindow = ImplGetCancelButton( pDialog );
326 0 : if ( !pWindow )
327 0 : pWindow = pDialog;
328 0 : Size aSize = pWindow->GetOutputSizePixel();
329 0 : pWindow->SetPointerPosPixel( Point( aSize.Width()/2, aSize.Height()/2 ) );
330 : }
331 5 : }
332 :
333 : struct DialogImpl
334 : {
335 : long mnResult;
336 : bool mbStartedModal;
337 : Link<> maEndDialogHdl;
338 :
339 12 : DialogImpl() : mnResult( -1 ), mbStartedModal( false ) {}
340 : };
341 :
342 12 : void Dialog::ImplInitDialogData()
343 : {
344 12 : mpWindowImpl->mbDialog = true;
345 12 : mpPrevExecuteDlg = NULL;
346 12 : mbInExecute = false;
347 12 : mbOldSaveBack = false;
348 12 : mbInClose = false;
349 12 : mbModalMode = false;
350 12 : mpContentArea.clear();
351 12 : mpActionArea.clear();
352 12 : mnMousePositioned = 0;
353 12 : mpDialogImpl = new DialogImpl;
354 12 : }
355 :
356 9 : void Dialog::ImplInit( vcl::Window* pParent, WinBits nStyle, InitFlag eFlag )
357 : {
358 9 : SystemWindowFlags nSysWinMode = Application::GetSystemWindowMode();
359 :
360 9 : if ( !(nStyle & WB_NODIALOGCONTROL) )
361 9 : nStyle |= WB_DIALOGCONTROL;
362 9 : nStyle |= WB_ROLLABLE;
363 :
364 : // Now, all Dialogs are per default system windows !!!
365 9 : nStyle |= WB_SYSTEMWINDOW;
366 :
367 9 : if (eFlag == InitFlag::NoParent)
368 3 : pParent = NULL;
369 6 : else if (!pParent) // parent is NULL: get the default Dialog parent
370 : {
371 2 : pParent = Application::GetDefDialogParent();
372 2 : if ( !pParent && !(nStyle & WB_SYSTEMWINDOW) )
373 0 : pParent = ImplGetSVData()->maWinData.mpAppWin;
374 :
375 : // If Parent is disabled, then we search for a modal dialog
376 : // in this frame
377 2 : if ( pParent && (!pParent->IsInputEnabled() || pParent->IsInModalMode()) )
378 : {
379 0 : ImplSVData* pSVData = ImplGetSVData();
380 0 : Dialog* pExeDlg = pSVData->maWinData.mpLastExecuteDlg;
381 0 : while ( pExeDlg )
382 : {
383 : // only if visible and enabled
384 0 : if ( pParent->ImplGetFirstOverlapWindow()->IsWindowOrChild( pExeDlg, true ) &&
385 0 : pExeDlg->IsReallyVisible() &&
386 0 : pExeDlg->IsEnabled() && pExeDlg->IsInputEnabled() && !pExeDlg->IsInModalMode() )
387 : {
388 0 : pParent = pExeDlg;
389 0 : break;
390 : }
391 :
392 0 : pExeDlg = pExeDlg->mpPrevExecuteDlg;
393 : }
394 : }
395 : }
396 :
397 40 : if ( !pParent || (nStyle & WB_SYSTEMWINDOW) ||
398 27 : (pParent->mpWindowImpl->mpFrameData->mbNeedSysWindow && !(nSysWinMode & SystemWindowFlags::NOAUTOMODE)) ||
399 9 : (nSysWinMode & SystemWindowFlags::DIALOG) )
400 : {
401 : // create window with a small border ?
402 9 : if ( (nStyle & (WB_BORDER | WB_NOBORDER | WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE)) == WB_BORDER )
403 : {
404 0 : VclPtrInstance<ImplBorderWindow> pBorderWin( pParent, nStyle, BORDERWINDOW_STYLE_FRAME );
405 0 : SystemWindow::ImplInit( pBorderWin, nStyle & ~WB_BORDER, NULL );
406 0 : pBorderWin->mpWindowImpl->mpClientWindow = this;
407 0 : pBorderWin->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder );
408 0 : mpWindowImpl->mpBorderWindow = pBorderWin;
409 0 : mpWindowImpl->mpRealParent = pParent;
410 : }
411 : else
412 : {
413 9 : mpWindowImpl->mbFrame = true;
414 9 : mpWindowImpl->mbOverlapWin = true;
415 9 : SystemWindow::ImplInit( pParent, (nStyle & (WB_MOVEABLE | WB_SIZEABLE | WB_ROLLABLE | WB_CLOSEABLE | WB_STANDALONE)) | WB_CLOSEABLE, NULL );
416 : // Now set all style bits
417 9 : mpWindowImpl->mnStyle = nStyle;
418 : }
419 : }
420 : else
421 : {
422 0 : VclPtrInstance<ImplBorderWindow> pBorderWin( pParent, nStyle, BORDERWINDOW_STYLE_OVERLAP | BORDERWINDOW_STYLE_BORDER );
423 0 : SystemWindow::ImplInit( pBorderWin, nStyle & ~WB_BORDER, NULL );
424 0 : pBorderWin->mpWindowImpl->mpClientWindow = this;
425 0 : pBorderWin->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder );
426 0 : mpWindowImpl->mpBorderWindow = pBorderWin;
427 0 : mpWindowImpl->mpRealParent = pParent;
428 : }
429 :
430 9 : SetActivateMode( ActivateModeFlags::GrabFocus );
431 :
432 9 : ImplInitSettings();
433 9 : }
434 :
435 7 : void Dialog::ApplySettings(vcl::RenderContext& rRenderContext)
436 : {
437 7 : if (IsControlBackground())
438 : {
439 : // user override
440 6 : SetBackground(GetControlBackground());
441 : }
442 1 : else if (rRenderContext.IsNativeControlSupported(CTRL_WINDOW_BACKGROUND, PART_BACKGROUND_DIALOG))
443 : {
444 : // NWF background
445 0 : mpWindowImpl->mnNativeBackground = PART_BACKGROUND_DIALOG;
446 0 : EnableChildTransparentMode(true);
447 : }
448 : else
449 : {
450 : // fallback to settings color
451 1 : rRenderContext.SetBackground(GetSettings().GetStyleSettings().GetDialogColor());
452 : }
453 7 : }
454 :
455 13 : void Dialog::ImplInitSettings()
456 : {
457 : // user override
458 13 : if (IsControlBackground())
459 4 : SetBackground(GetControlBackground());
460 : // NWF background
461 9 : else if( IsNativeControlSupported(CTRL_WINDOW_BACKGROUND, PART_BACKGROUND_DIALOG))
462 : {
463 0 : mpWindowImpl->mnNativeBackground = PART_BACKGROUND_DIALOG;
464 0 : EnableChildTransparentMode( true );
465 : }
466 : // fallback to settings color
467 : else
468 9 : SetBackground(GetSettings().GetStyleSettings().GetDialogColor());
469 13 : }
470 :
471 1 : Dialog::Dialog( WindowType nType )
472 : : SystemWindow( nType )
473 1 : , mnInitFlag(InitFlag::Default)
474 : {
475 1 : ImplInitDialogData();
476 1 : }
477 :
478 75157 : void VclBuilderContainer::disposeBuilder()
479 : {
480 75157 : if (m_pUIBuilder)
481 1638 : m_pUIBuilder->disposeBuilder();
482 75157 : }
483 :
484 1761 : OUString VclBuilderContainer::getUIRootDir()
485 : {
486 : /*to-do, check if user config has an override before using shared one, etc*/
487 : css::uno::Reference< css::util::XPathSettings > xPathSettings = css::util::thePathSettings::get(
488 1761 : ::comphelper::getProcessComponentContext() );
489 :
490 1761 : OUString sShareLayer = xPathSettings->getBasePathShareLayer();
491 :
492 : // "UIConfig" is a "multi path" ... use first part only here!
493 1761 : sal_Int32 nPos = sShareLayer.indexOf(';');
494 1761 : if (nPos > 0)
495 123 : sShareLayer = sShareLayer.copy(0, nPos);
496 :
497 : // Note: May be an user uses URLs without a final slash! Check it ...
498 1761 : if (!sShareLayer.endsWith("/"))
499 1761 : sShareLayer += "/";
500 :
501 1761 : sShareLayer += "soffice.cfg/";
502 : /*to-do, can we merge all this foo with existing soffice.cfg finding code, etc*/
503 1761 : return sShareLayer;
504 : }
505 :
506 : //we can't change sizeable after the fact, so need to defer until we know and then
507 : //do the init. Find the real parent stashed in mpDialogParent.
508 0 : void Dialog::doDeferredInit(WinBits nBits)
509 : {
510 0 : VclPtr<vcl::Window> pParent = mpDialogParent;
511 0 : mpDialogParent = NULL;
512 0 : ImplInit(pParent, nBits, mnInitFlag);
513 0 : mbIsDefferedInit = false;
514 0 : }
515 :
516 0 : Dialog::Dialog(vcl::Window* pParent, const OUString& rID, const OUString& rUIXMLDescription)
517 : : SystemWindow(WINDOW_DIALOG)
518 0 : , mnInitFlag(InitFlag::Default)
519 : {
520 0 : ImplInitDialogData();
521 0 : loadUI(pParent, OUStringToOString(rID, RTL_TEXTENCODING_UTF8), rUIXMLDescription);
522 0 : }
523 :
524 3 : Dialog::Dialog(vcl::Window* pParent, const OUString& rID, const OUString& rUIXMLDescription, WindowType nType, InitFlag eFlag)
525 : : SystemWindow(nType)
526 6 : , mnInitFlag(eFlag)
527 : {
528 3 : ImplInitDialogData();
529 6 : loadUI(pParent, OUStringToOString(rID, RTL_TEXTENCODING_UTF8), rUIXMLDescription);
530 0 : }
531 :
532 8 : Dialog::Dialog(vcl::Window* pParent, WinBits nStyle, InitFlag eFlag)
533 : : SystemWindow(WINDOW_DIALOG)
534 8 : , mnInitFlag(eFlag)
535 : {
536 8 : ImplInitDialogData();
537 8 : ImplInit( pParent, nStyle, eFlag );
538 8 : }
539 :
540 0 : void Dialog::set_action_area(VclButtonBox* pBox)
541 : {
542 0 : mpActionArea.set(pBox);
543 0 : }
544 :
545 0 : void Dialog::set_content_area(VclBox* pBox)
546 : {
547 0 : mpContentArea.set(pBox);
548 0 : }
549 :
550 1 : void Dialog::settingOptimalLayoutSize(Window *pBox)
551 : {
552 : const DialogStyle& rDialogStyle =
553 1 : GetSettings().GetStyleSettings().GetDialogStyle();
554 1 : VclBox * pBox2 = static_cast<VclBox*>(pBox);
555 1 : pBox2->set_border_width(rDialogStyle.content_area_border);
556 1 : pBox2->set_spacing(pBox2->get_spacing() +
557 1 : rDialogStyle.content_area_spacing);
558 :
559 1 : VclButtonBox *pActionArea = getActionArea(this);
560 1 : if (pActionArea)
561 : {
562 1 : pActionArea->set_border_width(rDialogStyle.action_area_border);
563 1 : pActionArea->set_spacing(rDialogStyle.button_spacing);
564 : }
565 1 : }
566 :
567 18 : Dialog::~Dialog()
568 : {
569 9 : disposeOnce();
570 9 : }
571 :
572 9 : void Dialog::dispose()
573 : {
574 9 : delete mpDialogImpl;
575 9 : mpDialogImpl = NULL;
576 9 : mpPrevExecuteDlg.clear();
577 9 : mpActionArea.clear();
578 9 : mpContentArea.clear();
579 9 : SystemWindow::dispose();
580 9 : }
581 :
582 0 : IMPL_LINK_NOARG(Dialog, ImplAsyncCloseHdl)
583 : {
584 0 : Close();
585 0 : return 0;
586 : }
587 :
588 79 : bool Dialog::Notify( NotifyEvent& rNEvt )
589 : {
590 : // first call the base class due to Tab control
591 79 : bool nRet = SystemWindow::Notify( rNEvt );
592 79 : if ( !nRet )
593 : {
594 79 : if ( rNEvt.GetType() == MouseNotifyEvent::KEYINPUT )
595 : {
596 0 : const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
597 0 : vcl::KeyCode aKeyCode = pKEvt->GetKeyCode();
598 0 : sal_uInt16 nKeyCode = aKeyCode.GetCode();
599 :
600 0 : if ( (nKeyCode == KEY_ESCAPE) &&
601 0 : ((GetStyle() & WB_CLOSEABLE) || ImplGetCancelButton( this ) || ImplGetOKButton( this )) )
602 : {
603 : // #i89505# for the benefit of slightly mentally challenged implementations
604 : // like e.g. SfxModelessDialog which destroy themselves inside Close()
605 : // post this Close asynchronous so we can leave our key handler before
606 : // we get destroyed
607 0 : PostUserEvent( LINK( this, Dialog, ImplAsyncCloseHdl ), this, true);
608 0 : return true;
609 : }
610 : }
611 79 : else if ( rNEvt.GetType() == MouseNotifyEvent::GETFOCUS )
612 : {
613 : // make sure the dialog is still modal
614 : // changing focus between application frames may
615 : // have re-enabled input for our parent
616 3 : if( mbInExecute && mbModalMode )
617 : {
618 : // do not change modal counter (pSVData->maAppData.mnModalDialog)
619 0 : SetModalInputMode( false );
620 0 : SetModalInputMode( true );
621 :
622 : // #93022# def-button might have changed after show
623 0 : if( !mnMousePositioned )
624 : {
625 0 : mnMousePositioned = 1;
626 0 : ImplMouseAutoPos( this );
627 : }
628 :
629 : }
630 : }
631 : }
632 :
633 79 : return nRet;
634 : }
635 :
636 : //What we really want here is something that gives the available width and
637 : //height of a users screen, taking away the space taken up the OS
638 : //taskbar, menus, etc.
639 51 : Size bestmaxFrameSizeForScreenSize(const Size &rScreenSize)
640 : {
641 51 : long w = rScreenSize.Width();
642 51 : if (w <= 800)
643 0 : w -= 15;
644 51 : else if (w <= 1024)
645 35 : w -= 65;
646 : else
647 16 : w -= 115;
648 :
649 51 : long h = rScreenSize.Height();
650 51 : if (h <= 768)
651 35 : h -= 50;
652 : else
653 16 : h -= 100;
654 :
655 51 : return Size(w, h);
656 : }
657 :
658 17 : void Dialog::StateChanged( StateChangedType nType )
659 : {
660 17 : if (nType == StateChangedType::InitShow)
661 : {
662 5 : DoInitialLayout();
663 :
664 5 : if ( !HasChildPathFocus() || HasFocus() )
665 5 : GrabFocusToFirstControl();
666 5 : if ( !(GetStyle() & WB_CLOSEABLE) )
667 : {
668 0 : if ( ImplGetCancelButton( this ) || ImplGetOKButton( this ) )
669 : {
670 0 : if ( ImplGetBorderWindow() )
671 0 : static_cast<ImplBorderWindow*>(ImplGetBorderWindow())->SetCloseButton();
672 : }
673 : }
674 :
675 5 : ImplMouseAutoPos( this );
676 : }
677 :
678 17 : SystemWindow::StateChanged( nType );
679 :
680 17 : if (nType == StateChangedType::ControlBackground)
681 : {
682 4 : ImplInitSettings();
683 4 : Invalidate();
684 : }
685 17 : }
686 :
687 0 : void Dialog::DataChanged( const DataChangedEvent& rDCEvt )
688 : {
689 0 : SystemWindow::DataChanged( rDCEvt );
690 :
691 0 : if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
692 0 : (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
693 : {
694 0 : ImplInitSettings();
695 0 : Invalidate();
696 : }
697 0 : }
698 :
699 0 : bool Dialog::Close()
700 : {
701 0 : ImplDelData aDelData;
702 0 : ImplAddDel( &aDelData );
703 0 : CallEventListeners( VCLEVENT_WINDOW_CLOSE );
704 0 : if ( aDelData.IsDead() )
705 0 : return false;
706 0 : ImplRemoveDel( &aDelData );
707 :
708 0 : if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() && !IsInExecute() )
709 0 : return false;
710 :
711 0 : mbInClose = true;
712 :
713 0 : if ( !(GetStyle() & WB_CLOSEABLE) )
714 : {
715 0 : bool bRet = true;
716 0 : ImplAddDel( &aDelData );
717 0 : PushButton* pButton = ImplGetCancelButton( this );
718 0 : if ( pButton )
719 0 : pButton->Click();
720 : else
721 : {
722 0 : pButton = ImplGetOKButton( this );
723 0 : if ( pButton )
724 0 : pButton->Click();
725 : else
726 0 : bRet = false;
727 : }
728 0 : if ( aDelData.IsDead() )
729 0 : return true;
730 0 : ImplRemoveDel( &aDelData );
731 0 : return bRet;
732 : }
733 :
734 0 : if ( IsInExecute() )
735 : {
736 0 : EndDialog( RET_CANCEL );
737 0 : mbInClose = false;
738 0 : return true;
739 : }
740 : else
741 : {
742 0 : mbInClose = false;
743 0 : return SystemWindow::Close();
744 0 : }
745 : }
746 :
747 0 : bool Dialog::ImplStartExecuteModal()
748 : {
749 0 : if ( mbInExecute )
750 : {
751 : #ifdef DBG_UTIL
752 : OStringBuffer aErrorStr;
753 : aErrorStr.append("Dialog::StartExecuteModal() is called in Dialog::StartExecuteModal(): ");
754 : aErrorStr.append(ImplGetDialogText(this));
755 : OSL_FAIL(aErrorStr.getStr());
756 : #endif
757 0 : return false;
758 : }
759 :
760 0 : switch ( Application::GetDialogCancelMode() )
761 : {
762 : case Application::DIALOG_CANCEL_OFF:
763 0 : break;
764 : case Application::DIALOG_CANCEL_SILENT:
765 : SAL_INFO(
766 : "vcl",
767 : "Dialog \"" << ImplGetDialogText(this).getStr()
768 : << "\"cancelled in silent mode");
769 0 : return false;
770 : default:
771 : assert(false && "this cannot happen");
772 : // fall through
773 : case Application::DIALOG_CANCEL_FATAL:
774 0 : std::abort();
775 : }
776 :
777 : #ifdef DBG_UTIL
778 : vcl::Window* pParent = GetParent();
779 : if ( pParent )
780 : {
781 : pParent = pParent->ImplGetFirstOverlapWindow();
782 : DBG_ASSERT( pParent->IsReallyVisible(),
783 : "Dialog::StartExecuteModal() - Parent not visible" );
784 : DBG_ASSERT( pParent->IsInputEnabled(),
785 : "Dialog::StartExecuteModal() - Parent input disabled, use another parent to ensure modality!" );
786 : DBG_ASSERT( ! pParent->IsInModalMode(),
787 : "Dialog::StartExecuteModal() - Parent already modally disabled, use another parent to ensure modality!" );
788 :
789 : }
790 : #endif
791 :
792 0 : ImplSVData* pSVData = ImplGetSVData();
793 :
794 : // link all dialogs which are being executed
795 0 : mpPrevExecuteDlg = pSVData->maWinData.mpLastExecuteDlg;
796 0 : pSVData->maWinData.mpLastExecuteDlg = this;
797 :
798 : // stop capturing, in order to have control over the dialog
799 0 : if ( pSVData->maWinData.mpTrackWin )
800 0 : pSVData->maWinData.mpTrackWin->EndTracking( TrackingEventFlags::Cancel );
801 0 : if ( pSVData->maWinData.mpCaptureWin )
802 0 : pSVData->maWinData.mpCaptureWin->ReleaseMouse();
803 0 : EnableInput( true, true );
804 :
805 0 : if ( GetParent() )
806 : {
807 0 : NotifyEvent aNEvt( MouseNotifyEvent::EXECUTEDIALOG, this );
808 0 : GetParent()->CompatNotify( aNEvt );
809 : }
810 0 : mbInExecute = true;
811 0 : SetModalInputMode( true );
812 0 : mbOldSaveBack = IsSaveBackgroundEnabled();
813 0 : EnableSaveBackground();
814 :
815 : // FIXME: no layouting, workaround some clipping issues
816 0 : ImplAdjustNWFSizes();
817 :
818 0 : Show();
819 :
820 0 : pSVData->maAppData.mnModalMode++;
821 0 : return true;
822 : }
823 :
824 0 : void Dialog::ImplEndExecuteModal()
825 : {
826 0 : ImplSVData* pSVData = ImplGetSVData();
827 0 : pSVData->maAppData.mnModalMode--;
828 0 : }
829 :
830 0 : short Dialog::Execute()
831 : {
832 : #if HAVE_FEATURE_DESKTOP
833 :
834 0 : setDeferredProperties();
835 :
836 0 : if ( !ImplStartExecuteModal() )
837 0 : return 0;
838 :
839 0 : ImplDelData aDelData;
840 0 : ImplAddDel( &aDelData );
841 :
842 : #ifdef DBG_UTIL
843 : ImplDelData aParentDelData;
844 : vcl::Window* pDialogParent = mpDialogParent;
845 : if( pDialogParent )
846 : pDialogParent->ImplAddDel( &aParentDelData );
847 : #endif
848 :
849 : // Yield util EndDialog is called or dialog gets destroyed
850 : // (the latter should not happen, but better safe than sorry
851 0 : while ( !aDelData.IsDead() && mbInExecute )
852 0 : Application::Yield();
853 :
854 0 : ImplEndExecuteModal();
855 :
856 : #ifdef DBG_UTIL
857 : if( pDialogParent )
858 : {
859 : if( ! aParentDelData.IsDead() )
860 : pDialogParent->ImplRemoveDel( &aParentDelData );
861 : else
862 : OSL_FAIL( "Dialog::Execute() - Parent of dialog destroyed in Execute()" );
863 : }
864 : #endif
865 0 : if ( !aDelData.IsDead() )
866 0 : ImplRemoveDel( &aDelData );
867 : #ifdef DBG_UTIL
868 : else
869 : {
870 : OSL_FAIL( "Dialog::Execute() - Dialog destroyed in Execute()" );
871 : }
872 : #endif
873 :
874 0 : long nRet = mpDialogImpl->mnResult;
875 0 : mpDialogImpl->mnResult = -1;
876 0 : return (short)nRet;
877 :
878 : #else
879 :
880 : // touch_ui_dialog_modal was dummied out both for Android and iOS (well, TiledLibreOffice anyway)
881 : // For Android it returned MLODialogOK always, for iOS Cancel. Let's go with OK.
882 : // MLODialogResult result = touch_ui_dialog_modal(kind, ImplGetDialogText(this).getStr());
883 : return RET_OK;
884 :
885 : #endif
886 : }
887 :
888 : // virtual
889 0 : void Dialog::StartExecuteModal( const Link<>& rEndDialogHdl )
890 : {
891 0 : if ( !ImplStartExecuteModal() )
892 0 : return;
893 :
894 0 : mpDialogImpl->maEndDialogHdl = rEndDialogHdl;
895 0 : mpDialogImpl->mbStartedModal = true;
896 : }
897 :
898 0 : void Dialog::EndDialog( long nResult )
899 : {
900 0 : if ( mbInExecute )
901 : {
902 0 : SetModalInputMode( false );
903 :
904 : // remove dialog from the list of dialogs which are being executed
905 0 : ImplSVData* pSVData = ImplGetSVData();
906 0 : Dialog* pExeDlg = pSVData->maWinData.mpLastExecuteDlg;
907 0 : while ( pExeDlg )
908 : {
909 0 : if ( pExeDlg == this )
910 : {
911 0 : pSVData->maWinData.mpLastExecuteDlg = mpPrevExecuteDlg;
912 0 : break;
913 : }
914 0 : pExeDlg = pExeDlg->mpPrevExecuteDlg;
915 : }
916 : // set focus to previous modal dialogue if it is modal for
917 : // the same frame parent (or NULL)
918 0 : if( mpPrevExecuteDlg )
919 : {
920 0 : vcl::Window* pFrameParent = ImplGetFrameWindow()->ImplGetParent();
921 0 : vcl::Window* pPrevFrameParent = mpPrevExecuteDlg->ImplGetFrameWindow()->ImplGetParent();
922 0 : if( ( !pFrameParent && !pPrevFrameParent ) ||
923 0 : ( pFrameParent && pPrevFrameParent && pFrameParent->ImplGetFrame() == pPrevFrameParent->ImplGetFrame() )
924 : )
925 : {
926 0 : mpPrevExecuteDlg->GrabFocus();
927 : }
928 : }
929 0 : mpPrevExecuteDlg = NULL;
930 :
931 0 : Hide();
932 0 : EnableSaveBackground( mbOldSaveBack );
933 0 : if ( GetParent() )
934 : {
935 0 : NotifyEvent aNEvt( MouseNotifyEvent::ENDEXECUTEDIALOG, this );
936 0 : GetParent()->CompatNotify( aNEvt );
937 : }
938 :
939 0 : mpDialogImpl->mnResult = nResult;
940 :
941 0 : if ( mpDialogImpl->mbStartedModal )
942 : {
943 0 : ImplEndExecuteModal();
944 0 : if (mpDialogImpl->maEndDialogHdl.IsSet())
945 : {
946 0 : mpDialogImpl->maEndDialogHdl.Call( this );
947 0 : mpDialogImpl->maEndDialogHdl = Link<>();
948 : }
949 0 : mpDialogImpl->mbStartedModal = false;
950 0 : mpDialogImpl->mnResult = -1;
951 : }
952 0 : mbInExecute = false;
953 : }
954 0 : }
955 :
956 0 : long Dialog::GetResult() const
957 : {
958 0 : return mpDialogImpl->mnResult;
959 : }
960 :
961 0 : void Dialog::EndAllDialogs( vcl::Window* pParent )
962 : {
963 0 : ImplSVData* pSVData = ImplGetSVData();
964 : Dialog* pTempModDialog;
965 0 : Dialog* pModDialog = pSVData->maWinData.mpLastExecuteDlg;
966 0 : while ( pModDialog )
967 : {
968 0 : pTempModDialog = pModDialog->mpPrevExecuteDlg;
969 0 : if( !pParent || ( pParent && pParent->IsWindowOrChild( pModDialog, true ) ) )
970 : {
971 0 : pModDialog->EndDialog( RET_CANCEL );
972 0 : pModDialog->PostUserEvent( Link<>() );
973 : }
974 0 : pModDialog = pTempModDialog;
975 : }
976 0 : }
977 :
978 0 : void Dialog::SetModalInputMode( bool bModal )
979 : {
980 0 : if ( bModal == mbModalMode )
981 0 : return;
982 :
983 0 : ImplSVData* pSVData = ImplGetSVData();
984 0 : mbModalMode = bModal;
985 0 : if ( bModal )
986 : {
987 0 : pSVData->maAppData.mnModalDialog++;
988 :
989 : // Diable the prev Modal Dialog, because our dialog must close at first,
990 : // before the other dialog can be closed (because the other dialog
991 : // is on stack since our dialog returns)
992 0 : if ( mpPrevExecuteDlg && !mpPrevExecuteDlg->IsWindowOrChild( this, true ) )
993 0 : mpPrevExecuteDlg->EnableInput( false, true, true, this );
994 :
995 : // determine next overlap dialog parent
996 0 : vcl::Window* pParent = GetParent();
997 0 : if ( pParent )
998 : {
999 : // #103716# dialogs should always be modal to the whole frame window
1000 : // #115933# disable the whole frame hierarchy, useful if our parent
1001 : // is a modeless dialog
1002 0 : mpDialogParent = pParent->mpWindowImpl->mpFrameWindow;
1003 0 : mpDialogParent->ImplIncModalCount();
1004 : }
1005 :
1006 : }
1007 : else
1008 : {
1009 0 : pSVData->maAppData.mnModalDialog--;
1010 :
1011 0 : if ( mpDialogParent )
1012 : {
1013 : // #115933# re-enable the whole frame hierarchy again (see above)
1014 : // note that code in getfocus assures that we do not accidentally enable
1015 : // windows that were disabled before
1016 0 : mpDialogParent->ImplDecModalCount();
1017 : }
1018 :
1019 : // Enable the prev Modal Dialog
1020 0 : if ( mpPrevExecuteDlg && !mpPrevExecuteDlg->IsWindowOrChild( this, true ) )
1021 : {
1022 0 : mpPrevExecuteDlg->EnableInput( true, true, true, this );
1023 : // ensure continued modality of prev dialog
1024 : // do not change modality counter
1025 :
1026 : // #i119994# need find the last modal dialog before reactive it
1027 0 : Dialog * pPrevModalDlg = mpPrevExecuteDlg;
1028 :
1029 0 : while( pPrevModalDlg && !pPrevModalDlg->IsModalInputMode() )
1030 0 : pPrevModalDlg = pPrevModalDlg->mpPrevExecuteDlg;
1031 :
1032 0 : if( pPrevModalDlg &&
1033 0 : ( pPrevModalDlg == mpPrevExecuteDlg.get()
1034 0 : || !pPrevModalDlg->IsWindowOrChild( this, true ) ) )
1035 : {
1036 0 : mpPrevExecuteDlg->SetModalInputMode( false );
1037 0 : mpPrevExecuteDlg->SetModalInputMode( true );
1038 : }
1039 : }
1040 : }
1041 : }
1042 :
1043 0 : void Dialog::SetModalInputMode( bool bModal, bool bSubModalDialogs )
1044 : {
1045 0 : if ( bSubModalDialogs )
1046 : {
1047 0 : vcl::Window* pOverlap = ImplGetFirstOverlapWindow();
1048 0 : pOverlap = pOverlap->mpWindowImpl->mpFirstOverlap;
1049 0 : while ( pOverlap )
1050 : {
1051 0 : if ( pOverlap->IsDialog() )
1052 0 : static_cast<Dialog*>(pOverlap)->SetModalInputMode( bModal, true );
1053 0 : pOverlap = pOverlap->mpWindowImpl->mpNext;
1054 : }
1055 : }
1056 :
1057 0 : SetModalInputMode( bModal );
1058 0 : }
1059 :
1060 5 : void Dialog::GrabFocusToFirstControl()
1061 : {
1062 : vcl::Window* pFocusControl;
1063 :
1064 : // find focus control, even if the dialog has focus
1065 5 : if ( HasFocus() )
1066 0 : pFocusControl = NULL;
1067 : else
1068 : {
1069 : // prefer a child window which had focus before
1070 5 : pFocusControl = ImplGetFirstOverlapWindow()->mpWindowImpl->mpLastFocusWindow;
1071 : // find the control out of the dialog control
1072 5 : if ( pFocusControl )
1073 0 : pFocusControl = ImplFindDlgCtrlWindow( pFocusControl );
1074 : }
1075 : // no control had the focus before or the control is not
1076 : // part of the tab-control, now give focus to the
1077 : // first control in the tab-control
1078 5 : if ( !pFocusControl ||
1079 0 : !(pFocusControl->GetStyle() & WB_TABSTOP) ||
1080 0 : !isVisibleInLayout(pFocusControl) ||
1081 5 : !isEnabledInLayout(pFocusControl) || !pFocusControl->IsInputEnabled() )
1082 : {
1083 5 : sal_uInt16 n = 0;
1084 5 : pFocusControl = ImplGetDlgWindow( n, GetDlgWindowType::First );
1085 : }
1086 5 : if ( pFocusControl )
1087 0 : pFocusControl->ImplControlFocus( GetFocusFlags::Init );
1088 5 : }
1089 :
1090 0 : void Dialog::GetDrawWindowBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder, sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const
1091 : {
1092 0 : ScopedVclPtrInstance<ImplBorderWindow> aImplWin( static_cast<vcl::Window*>(const_cast<Dialog *>(this)), WB_BORDER|WB_STDWORK, BORDERWINDOW_STYLE_OVERLAP );
1093 0 : aImplWin->GetBorder( rLeftBorder, rTopBorder, rRightBorder, rBottomBorder );
1094 0 : }
1095 :
1096 0 : void Dialog::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, DrawFlags )
1097 : {
1098 0 : Point aPos = pDev->LogicToPixel( rPos );
1099 0 : Size aSize = pDev->LogicToPixel( rSize );
1100 :
1101 0 : Wallpaper aWallpaper = GetBackground();
1102 0 : if ( !aWallpaper.IsBitmap() )
1103 0 : ImplInitSettings();
1104 :
1105 0 : pDev->Push();
1106 0 : pDev->SetMapMode();
1107 0 : pDev->SetLineColor();
1108 :
1109 0 : if ( aWallpaper.IsBitmap() )
1110 0 : pDev->DrawBitmapEx( aPos, aSize, aWallpaper.GetBitmap() );
1111 : else
1112 : {
1113 0 : pDev->SetFillColor( aWallpaper.GetColor() );
1114 0 : pDev->DrawRect( Rectangle( aPos, aSize ) );
1115 : }
1116 :
1117 0 : if (!( GetStyle() & WB_NOBORDER ))
1118 : {
1119 0 : ScopedVclPtrInstance< ImplBorderWindow > aImplWin( this, WB_BORDER|WB_STDWORK, BORDERWINDOW_STYLE_OVERLAP );
1120 0 : aImplWin->SetText( GetText() );
1121 0 : aImplWin->setPosSizePixel( aPos.X(), aPos.Y(), aSize.Width(), aSize.Height() );
1122 0 : aImplWin->SetDisplayActive( true );
1123 0 : aImplWin->InitView();
1124 :
1125 0 : aImplWin->Draw( Rectangle( aPos, aSize ), pDev, aPos );
1126 : }
1127 :
1128 0 : pDev->Pop();
1129 0 : }
1130 :
1131 134 : void Dialog::queue_resize(StateChangedType eReason)
1132 : {
1133 134 : if (IsInClose())
1134 134 : return;
1135 134 : SystemWindow::queue_resize(eReason);
1136 : }
1137 :
1138 0 : bool Dialog::set_property(const OString &rKey, const OString &rValue)
1139 : {
1140 0 : if (rKey == "border-width")
1141 0 : set_border_width(rValue.toInt32());
1142 : else
1143 0 : return SystemWindow::set_property(rKey, rValue);
1144 0 : return true;
1145 : }
1146 :
1147 75378 : VclBuilderContainer::VclBuilderContainer()
1148 75378 : : m_pUIBuilder(NULL)
1149 : {
1150 75378 : }
1151 :
1152 72712 : VclBuilderContainer::~VclBuilderContainer()
1153 : {
1154 72712 : delete m_pUIBuilder;
1155 72712 : }
1156 :
1157 0 : ModelessDialog::ModelessDialog(vcl::Window* pParent, const OUString& rID, const OUString& rUIXMLDescription, InitFlag eFlag)
1158 0 : : Dialog(pParent, rID, rUIXMLDescription, WINDOW_MODELESSDIALOG, eFlag)
1159 : {
1160 0 : }
1161 :
1162 1 : ModalDialog::ModalDialog( vcl::Window* pParent, WinBits nStyle ) :
1163 1 : Dialog( WINDOW_MODALDIALOG )
1164 : {
1165 1 : ImplInit( pParent, nStyle );
1166 1 : }
1167 :
1168 3 : ModalDialog::ModalDialog( vcl::Window* pParent, const OUString& rID, const OUString& rUIXMLDescription ) :
1169 3 : Dialog(pParent, rID, rUIXMLDescription, WINDOW_MODALDIALOG)
1170 : {
1171 801 : }
1172 :
1173 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
