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 <com/sun/star/beans/XPropertySet.hpp>
21 : #include <comphelper/processfactory.hxx>
22 : #include <osl/file.hxx>
23 :
24 : #include <tools/debug.hxx>
25 :
26 : #include <tools/rc.h>
27 : #include <svdata.hxx>
28 : #include <window.h>
29 : #include <brdwin.hxx>
30 :
31 : #include <rtl/strbuf.hxx>
32 : #include <sal/log.hxx>
33 :
34 : #include <vcl/builder.hxx>
35 : #include <vcl/layout.hxx>
36 : #include <vcl/svapp.hxx>
37 : #include <vcl/event.hxx>
38 : #include <vcl/wrkwin.hxx>
39 : #include <vcl/button.hxx>
40 : #include <vcl/mnemonic.hxx>
41 : #include <vcl/dialog.hxx>
42 : #include <vcl/decoview.hxx>
43 : #include <vcl/msgbox.hxx>
44 : #include <vcl/unowrap.hxx>
45 : #include <iostream>
46 :
47 : #ifdef ANDROID
48 : #include <osl/detail/android-bootstrap.h>
49 : #endif
50 :
51 : // =======================================================================
52 :
53 : #ifndef ANDROID
54 :
55 0 : static rtl::OString ImplGetDialogText( Dialog* pDialog )
56 : {
57 : rtl::OStringBuffer aErrorStr(rtl::OUStringToOString(
58 0 : pDialog->GetText(), RTL_TEXTENCODING_UTF8));
59 0 : if ( (pDialog->GetType() == WINDOW_MESSBOX) ||
60 0 : (pDialog->GetType() == WINDOW_INFOBOX) ||
61 0 : (pDialog->GetType() == WINDOW_WARNINGBOX) ||
62 0 : (pDialog->GetType() == WINDOW_ERRORBOX) ||
63 0 : (pDialog->GetType() == WINDOW_QUERYBOX) )
64 : {
65 0 : aErrorStr.append(", ");
66 : aErrorStr.append(rtl::OUStringToOString(
67 0 : ((MessBox*)pDialog)->GetMessText(), RTL_TEXTENCODING_UTF8));
68 : }
69 0 : return aErrorStr.makeStringAndClear();
70 : }
71 :
72 : #endif
73 :
74 : // =======================================================================
75 :
76 0 : static sal_Bool ImplIsMnemonicCtrl( Window* pWindow )
77 : {
78 0 : if( ! pWindow->GetSettings().GetStyleSettings().GetAutoMnemonic() )
79 0 : return sal_False;
80 :
81 0 : if ( (pWindow->GetType() == WINDOW_RADIOBUTTON) ||
82 0 : (pWindow->GetType() == WINDOW_CHECKBOX) ||
83 0 : (pWindow->GetType() == WINDOW_TRISTATEBOX) ||
84 0 : (pWindow->GetType() == WINDOW_PUSHBUTTON) )
85 0 : return sal_True;
86 :
87 0 : if ( pWindow->GetType() == WINDOW_FIXEDTEXT )
88 : {
89 0 : if ( pWindow->GetStyle() & (WB_INFO | WB_NOLABEL) )
90 0 : return sal_False;
91 0 : Window* pNextWindow = pWindow->GetWindow( WINDOW_NEXT );
92 0 : if ( !pNextWindow )
93 0 : return sal_False;
94 0 : pNextWindow = pNextWindow->GetWindow( WINDOW_CLIENT );
95 0 : if ( !(pNextWindow->GetStyle() & WB_TABSTOP) ||
96 0 : (pNextWindow->GetType() == WINDOW_FIXEDTEXT) ||
97 0 : (pNextWindow->GetType() == WINDOW_GROUPBOX) ||
98 0 : (pNextWindow->GetType() == WINDOW_RADIOBUTTON) ||
99 0 : (pNextWindow->GetType() == WINDOW_CHECKBOX) ||
100 0 : (pNextWindow->GetType() == WINDOW_TRISTATEBOX) ||
101 0 : (pNextWindow->GetType() == WINDOW_PUSHBUTTON) )
102 0 : return sal_False;
103 :
104 0 : return sal_True;
105 : }
106 :
107 0 : return sal_False;
108 : }
109 :
110 : // -----------------------------------------------------------------------
111 :
112 : // Called by native error dialog popup implementations
113 0 : void ImplHideSplash()
114 : {
115 0 : ImplSVData* pSVData = ImplGetSVData();
116 0 : if( pSVData->mpIntroWindow )
117 0 : pSVData->mpIntroWindow->Hide();
118 0 : }
119 :
120 : //Get next window after pChild of a pTopLevel window as
121 : //if any intermediate layout widgets didn't exist
122 248 : Window * nextLogicalChildOfParent(Window *pTopLevel, Window *pChild)
123 : {
124 248 : Window *pLastChild = pChild;
125 :
126 248 : if (isContainerWindow(*pChild))
127 0 : pChild = pChild->GetWindow(WINDOW_FIRSTCHILD);
128 : else
129 248 : pChild = pChild->GetWindow(WINDOW_NEXT);
130 :
131 496 : while (!pChild)
132 : {
133 48 : Window *pParent = pLastChild->GetParent();
134 48 : if (!pParent)
135 0 : return NULL;
136 48 : if (pParent == pTopLevel)
137 48 : return NULL;
138 0 : pLastChild = pParent;
139 0 : pChild = pParent->GetWindow(WINDOW_NEXT);
140 : }
141 :
142 200 : if (pChild && isContainerWindow(*pChild))
143 0 : pChild = nextLogicalChildOfParent(pTopLevel, pChild);
144 :
145 200 : return pChild;
146 : }
147 :
148 0 : Window * prevLogicalChildOfParent(Window *pTopLevel, Window *pChild)
149 : {
150 0 : Window *pLastChild = pChild;
151 :
152 0 : if (isContainerWindow(*pChild))
153 0 : pChild = pChild->GetWindow(WINDOW_LASTCHILD);
154 : else
155 0 : pChild = pChild->GetWindow(WINDOW_PREV);
156 :
157 0 : while (!pChild)
158 : {
159 0 : Window *pParent = pLastChild->GetParent();
160 0 : if (!pParent)
161 0 : return NULL;
162 0 : if (pParent == pTopLevel)
163 0 : return NULL;
164 0 : pLastChild = pParent;
165 0 : pChild = pParent->GetWindow(WINDOW_PREV);
166 : }
167 :
168 0 : if (pChild && isContainerWindow(*pChild))
169 0 : pChild = prevLogicalChildOfParent(pTopLevel, pChild);
170 :
171 0 : return pChild;
172 : }
173 :
174 : //Get first window of a pTopLevel window as
175 : //if any intermediate layout widgets didn't exist
176 764 : Window * firstLogicalChildOfParent(Window *pTopLevel)
177 : {
178 764 : Window *pChild = pTopLevel->GetWindow(WINDOW_FIRSTCHILD);
179 764 : if (pChild && isContainerWindow(*pChild))
180 0 : pChild = nextLogicalChildOfParent(pTopLevel, pChild);
181 764 : return pChild;
182 : }
183 :
184 : // -----------------------------------------------------------------------
185 :
186 0 : void ImplWindowAutoMnemonic( Window* pWindow )
187 : {
188 0 : MnemonicGenerator aMnemonicGenerator;
189 : Window* pGetChild;
190 : Window* pChild;
191 :
192 : // Die schon vergebenen Mnemonics registieren
193 0 : pGetChild = pWindow->GetWindow( WINDOW_FIRSTCHILD );
194 0 : while ( pGetChild )
195 : {
196 0 : pChild = pGetChild->ImplGetWindow();
197 0 : aMnemonicGenerator.RegisterMnemonic( pChild->GetText() );
198 0 : pGetChild = nextLogicalChildOfParent(pWindow, pGetChild);
199 : }
200 :
201 : // Bei TabPages auch noch die Controls vom Dialog beruecksichtigen
202 0 : if ( pWindow->GetType() == WINDOW_TABPAGE )
203 : {
204 0 : Window* pParent = pWindow->GetParent();
205 0 : if ( pParent->GetType() == WINDOW_TABCONTROL )
206 0 : pParent = pParent->GetParent();
207 :
208 0 : if ( (pParent->GetStyle() & (WB_DIALOGCONTROL | WB_NODIALOGCONTROL)) == WB_DIALOGCONTROL )
209 : {
210 0 : pGetChild = pParent->GetWindow( WINDOW_FIRSTCHILD );
211 0 : while ( pGetChild )
212 : {
213 0 : pChild = pGetChild->ImplGetWindow();
214 0 : aMnemonicGenerator.RegisterMnemonic( pChild->GetText() );
215 0 : pGetChild = nextLogicalChildOfParent(pWindow, pGetChild);
216 : }
217 : }
218 : }
219 :
220 : // Die Mnemonics an die Controls vergeben, die noch keinen haben
221 0 : pGetChild = pWindow->GetWindow( WINDOW_FIRSTCHILD );
222 0 : while ( pGetChild )
223 : {
224 0 : pChild = pGetChild->ImplGetWindow();
225 0 : if ( ImplIsMnemonicCtrl( pChild ) )
226 : {
227 0 : XubString aText = pChild->GetText();
228 0 : if ( aMnemonicGenerator.CreateMnemonic( aText ) )
229 0 : pChild->SetText( aText );
230 : }
231 :
232 0 : pGetChild = nextLogicalChildOfParent(pWindow, pGetChild);
233 0 : }
234 0 : }
235 :
236 0 : static VclButtonBox* getActionArea(Dialog *pDialog)
237 : {
238 0 : VclButtonBox *pButtonBox = NULL;
239 0 : if (pDialog->isLayoutEnabled())
240 : {
241 0 : Window *pBox = pDialog->GetWindow(WINDOW_FIRSTCHILD);
242 0 : Window *pChild = pBox->GetWindow(WINDOW_LASTCHILD);
243 0 : while (pChild)
244 : {
245 0 : pButtonBox = dynamic_cast<VclButtonBox*>(pChild);
246 0 : if (pButtonBox)
247 0 : break;
248 0 : pChild = pChild->GetWindow(WINDOW_PREV);
249 : }
250 : }
251 0 : return pButtonBox;
252 : }
253 :
254 0 : static Window* getActionAreaButtonList(Dialog *pDialog)
255 : {
256 0 : VclButtonBox* pButtonBox = getActionArea(pDialog);
257 0 : if (pButtonBox)
258 0 : return pButtonBox->GetWindow(WINDOW_FIRSTCHILD);
259 0 : return pDialog->GetWindow(WINDOW_FIRSTCHILD);
260 : }
261 :
262 : // =======================================================================
263 :
264 0 : static PushButton* ImplGetDefaultButton( Dialog* pDialog )
265 : {
266 0 : Window* pChild = getActionAreaButtonList(pDialog);
267 0 : while ( pChild )
268 : {
269 0 : if ( pChild->ImplIsPushButton() )
270 : {
271 0 : PushButton* pPushButton = (PushButton*)pChild;
272 0 : if ( pPushButton->ImplIsDefButton() )
273 0 : return pPushButton;
274 : }
275 :
276 0 : pChild = pChild->GetWindow( WINDOW_NEXT );
277 : }
278 :
279 0 : return NULL;
280 : }
281 :
282 : // -----------------------------------------------------------------------
283 :
284 0 : static PushButton* ImplGetOKButton( Dialog* pDialog )
285 : {
286 0 : Window* pChild = getActionAreaButtonList(pDialog);
287 0 : while ( pChild )
288 : {
289 0 : if ( pChild->GetType() == WINDOW_OKBUTTON )
290 0 : return (PushButton*)pChild;
291 :
292 0 : pChild = pChild->GetWindow( WINDOW_NEXT );
293 : }
294 :
295 0 : return NULL;
296 : }
297 :
298 : // -----------------------------------------------------------------------
299 :
300 0 : static PushButton* ImplGetCancelButton( Dialog* pDialog )
301 : {
302 0 : Window* pChild = getActionAreaButtonList(pDialog);
303 :
304 0 : while ( pChild )
305 : {
306 0 : if ( pChild->GetType() == WINDOW_CANCELBUTTON )
307 0 : return (PushButton*)pChild;
308 :
309 0 : pChild = pChild->GetWindow( WINDOW_NEXT );
310 : }
311 :
312 0 : return NULL;
313 : }
314 :
315 : // -----------------------------------------------------------------------
316 :
317 0 : static void ImplMouseAutoPos( Dialog* pDialog )
318 : {
319 0 : sal_uLong nMouseOptions = pDialog->GetSettings().GetMouseSettings().GetOptions();
320 0 : if ( nMouseOptions & MOUSE_OPTION_AUTOCENTERPOS )
321 : {
322 0 : Size aSize = pDialog->GetOutputSizePixel();
323 0 : pDialog->SetPointerPosPixel( Point( aSize.Width()/2, aSize.Height()/2 ) );
324 : }
325 0 : else if ( nMouseOptions & MOUSE_OPTION_AUTODEFBTNPOS )
326 : {
327 0 : Window* pWindow = ImplGetDefaultButton( pDialog );
328 0 : if ( !pWindow )
329 0 : pWindow = ImplGetOKButton( pDialog );
330 0 : if ( !pWindow )
331 0 : pWindow = ImplGetCancelButton( pDialog );
332 0 : if ( !pWindow )
333 0 : pWindow = pDialog;
334 0 : Size aSize = pWindow->GetOutputSizePixel();
335 0 : pWindow->SetPointerPosPixel( Point( aSize.Width()/2, aSize.Height()/2 ) );
336 : }
337 0 : }
338 :
339 : // =======================================================================
340 :
341 : struct DialogImpl
342 : {
343 : long mnResult;
344 : bool mbStartedModal;
345 : Link maEndDialogHdl;
346 :
347 0 : DialogImpl() : mnResult( -1 ), mbStartedModal( false ) {}
348 : };
349 :
350 : // =======================================================================
351 :
352 0 : void Dialog::ImplInitDialogData()
353 : {
354 0 : mpWindowImpl->mbDialog = sal_True;
355 0 : mpDialogParent = NULL;
356 0 : mpPrevExecuteDlg = NULL;
357 0 : mbInExecute = sal_False;
358 0 : mbOldSaveBack = sal_False;
359 0 : mbInClose = sal_False;
360 0 : mbModalMode = sal_False;
361 0 : mnMousePositioned = 0;
362 0 : mpDialogImpl = new DialogImpl;
363 :
364 : //To-Do, reuse maResizeTimer
365 0 : maLayoutTimer.SetTimeout(50);
366 0 : maLayoutTimer.SetTimeoutHdl( LINK( this, Dialog, ImplHandleLayoutTimerHdl ) );
367 0 : }
368 :
369 : // -----------------------------------------------------------------------
370 :
371 0 : void Dialog::ImplInit( Window* pParent, WinBits nStyle )
372 : {
373 0 : sal_uInt16 nSysWinMode = Application::GetSystemWindowMode();
374 :
375 0 : if ( !(nStyle & WB_NODIALOGCONTROL) )
376 0 : nStyle |= WB_DIALOGCONTROL;
377 0 : nStyle |= WB_ROLLABLE;
378 :
379 : // Now, all Dialogs are per default system windows !!!
380 0 : nStyle |= WB_SYSTEMWINDOW;
381 :
382 :
383 : // parent is NULL: get the default Dialog parent
384 0 : if ( !pParent )
385 : {
386 0 : pParent = Application::GetDefDialogParent();
387 0 : if ( !pParent && !(nStyle & WB_SYSTEMWINDOW) )
388 0 : pParent = ImplGetSVData()->maWinData.mpAppWin;
389 :
390 : // If Parent is disabled, then we search for a modal dialog
391 : // in this frame
392 0 : if ( pParent && (!pParent->IsInputEnabled() || pParent->IsInModalMode()) )
393 : {
394 0 : ImplSVData* pSVData = ImplGetSVData();
395 0 : Dialog* pExeDlg = pSVData->maWinData.mpLastExecuteDlg;
396 0 : while ( pExeDlg )
397 : {
398 : // Nur wenn er sichtbar und enabled ist
399 0 : if ( pParent->ImplGetFirstOverlapWindow()->IsWindowOrChild( pExeDlg, sal_True ) &&
400 0 : pExeDlg->IsReallyVisible() &&
401 0 : pExeDlg->IsEnabled() && pExeDlg->IsInputEnabled() && !pExeDlg->IsInModalMode() )
402 : {
403 0 : pParent = pExeDlg;
404 0 : break;
405 : }
406 :
407 0 : pExeDlg = pExeDlg->mpPrevExecuteDlg;
408 : }
409 : }
410 : }
411 : // DIALOG_NO_PARENT: explicitly don't have a parent for this Dialog
412 0 : else if( pParent == DIALOG_NO_PARENT )
413 0 : pParent = NULL;
414 :
415 :
416 0 : if ( !pParent || (nStyle & WB_SYSTEMWINDOW) ||
417 0 : (pParent->mpWindowImpl->mpFrameData->mbNeedSysWindow && !(nSysWinMode & SYSTEMWINDOW_MODE_NOAUTOMODE)) ||
418 : (nSysWinMode & SYSTEMWINDOW_MODE_DIALOG) )
419 : {
420 : // create window with a small border ?
421 0 : if ( (nStyle & (WB_BORDER | WB_NOBORDER | WB_MOVEABLE | WB_SIZEABLE | WB_CLOSEABLE)) == WB_BORDER )
422 : {
423 0 : ImplBorderWindow* pBorderWin = new ImplBorderWindow( pParent, nStyle, BORDERWINDOW_STYLE_FRAME );
424 0 : SystemWindow::ImplInit( pBorderWin, nStyle & ~WB_BORDER, NULL );
425 0 : pBorderWin->mpWindowImpl->mpClientWindow = this;
426 0 : pBorderWin->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder );
427 0 : mpWindowImpl->mpBorderWindow = pBorderWin;
428 0 : mpWindowImpl->mpRealParent = pParent;
429 : }
430 : else
431 : {
432 0 : mpWindowImpl->mbFrame = sal_True;
433 0 : mpWindowImpl->mbOverlapWin = sal_True;
434 0 : SystemWindow::ImplInit( pParent, (nStyle & (WB_MOVEABLE | WB_SIZEABLE | WB_ROLLABLE | WB_CLOSEABLE | WB_STANDALONE)) | WB_CLOSEABLE, NULL );
435 : // Now set all style bits
436 0 : mpWindowImpl->mnStyle = nStyle;
437 0 : }
438 : }
439 : else
440 : {
441 0 : ImplBorderWindow* pBorderWin = new ImplBorderWindow( pParent, nStyle, BORDERWINDOW_STYLE_OVERLAP | BORDERWINDOW_STYLE_BORDER );
442 0 : SystemWindow::ImplInit( pBorderWin, nStyle & ~WB_BORDER, NULL );
443 0 : pBorderWin->mpWindowImpl->mpClientWindow = this;
444 0 : pBorderWin->GetBorder( mpWindowImpl->mnLeftBorder, mpWindowImpl->mnTopBorder, mpWindowImpl->mnRightBorder, mpWindowImpl->mnBottomBorder );
445 0 : mpWindowImpl->mpBorderWindow = pBorderWin;
446 0 : mpWindowImpl->mpRealParent = pParent;
447 : }
448 :
449 0 : SetActivateMode( ACTIVATE_MODE_GRABFOCUS );
450 :
451 0 : ImplInitSettings();
452 0 : }
453 :
454 : // -----------------------------------------------------------------------
455 :
456 0 : void Dialog::ImplInitSettings()
457 : {
458 : // user override
459 0 : if ( IsControlBackground() )
460 0 : SetBackground( GetControlBackground() );
461 : // NWF background
462 0 : else if( IsNativeControlSupported( CTRL_WINDOW_BACKGROUND, PART_BACKGROUND_DIALOG ) )
463 : {
464 0 : mpWindowImpl->mnNativeBackground = PART_BACKGROUND_DIALOG;
465 0 : EnableChildTransparentMode( sal_True );
466 : }
467 : // fallback to settings color
468 : else
469 0 : SetBackground( GetSettings().GetStyleSettings().GetDialogColor() );
470 0 : }
471 :
472 : // -----------------------------------------------------------------------
473 :
474 0 : Dialog::Dialog( WindowType nType )
475 : : SystemWindow( nType )
476 0 : , mbIsDefferedInit(false)
477 : {
478 0 : ImplInitDialogData();
479 0 : }
480 :
481 : #define BASEPATH_SHARE_LAYER rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("UIConfig"))
482 : #define RELPATH_SHARE_LAYER rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("soffice.cfg"))
483 : #define SERVICENAME_PATHSETTINGS rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.util.PathSettings"))
484 :
485 0 : rtl::OUString VclBuilderContainer::getUIRootDir()
486 : {
487 : /*to-do, check if user config has an override before using shared one, etc*/
488 : css::uno::Reference< css::beans::XPropertySet > xPathSettings(
489 0 : ::comphelper::getProcessServiceFactory()->createInstance(SERVICENAME_PATHSETTINGS),
490 0 : css::uno::UNO_QUERY_THROW);
491 :
492 0 : ::rtl::OUString sShareLayer;
493 0 : xPathSettings->getPropertyValue(BASEPATH_SHARE_LAYER) >>= sShareLayer;
494 :
495 : // "UIConfig" is a "multi path" ... use first part only here!
496 0 : sal_Int32 nPos = sShareLayer.indexOf(';');
497 0 : if (nPos > 0)
498 0 : sShareLayer = sShareLayer.copy(0, nPos);
499 :
500 : // Note: May be an user uses URLs without a final slash! Check it ...
501 0 : nPos = sShareLayer.lastIndexOf('/');
502 0 : if (nPos != sShareLayer.getLength()-1)
503 0 : sShareLayer += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));
504 :
505 0 : sShareLayer += RELPATH_SHARE_LAYER; // folder
506 0 : sShareLayer += ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("/"));
507 : /*to-do, can we merge all this foo with existing soffice.cfg finding code, etc*/
508 0 : return sShareLayer;
509 : }
510 :
511 : //we can't change sizeable after the fact, so need to defer until we know and then
512 : //do the init. Find the real parent stashed in mpDialogParent.
513 0 : void Dialog::doDeferredInit(bool bResizable)
514 : {
515 0 : WinBits nBits = WB_3DLOOK|WB_CLOSEABLE|WB_MOVEABLE;
516 0 : if (bResizable)
517 0 : nBits |= WB_SIZEABLE;
518 0 : Window *pParent = mpDialogParent;
519 0 : mpDialogParent = NULL;
520 0 : ImplInit(pParent, nBits);
521 0 : mbIsDefferedInit = false;
522 0 : }
523 :
524 0 : Dialog::Dialog(Window* pParent, const rtl::OString& rID, const rtl::OUString& rUIXMLDescription)
525 : : SystemWindow( WINDOW_DIALOG )
526 0 : , mbIsDefferedInit(true)
527 : {
528 0 : ImplInitDialogData();
529 0 : mpDialogParent = pParent; //will be unset in doDeferredInit
530 0 : m_pUIBuilder = new VclBuilder(this, getUIRootDir(), rUIXMLDescription, rID);
531 0 : }
532 :
533 0 : Dialog::Dialog(Window* pParent, const rtl::OString& rID, const rtl::OUString& rUIXMLDescription, WindowType nType)
534 : : SystemWindow( nType )
535 0 : , mbIsDefferedInit(true)
536 : {
537 0 : ImplInitDialogData();
538 0 : mpDialogParent = pParent; //will be unset in doDeferredInit
539 0 : m_pUIBuilder = new VclBuilder(this, getUIRootDir(), rUIXMLDescription, rID);
540 0 : }
541 :
542 :
543 : // -----------------------------------------------------------------------
544 :
545 0 : Dialog::Dialog( Window* pParent, WinBits nStyle )
546 : : SystemWindow( WINDOW_DIALOG )
547 0 : , mbIsDefferedInit(false)
548 : {
549 0 : ImplInitDialogData();
550 0 : ImplInit( pParent, nStyle );
551 0 : }
552 :
553 0 : WinBits Dialog::init(Window *pParent, const ResId& rResId)
554 : {
555 0 : WinBits nStyle = ImplInitRes( rResId );
556 :
557 0 : ImplInit( pParent, nStyle );
558 0 : ImplLoadRes( rResId );
559 :
560 0 : return nStyle;
561 : }
562 :
563 0 : VclButtonBox* Dialog::get_action_area()
564 : {
565 0 : return m_pUIBuilder ? m_pUIBuilder->get<VclButtonBox>("dialog-action_area1") : NULL;
566 : }
567 :
568 0 : VclBox* Dialog::get_content_area()
569 : {
570 0 : return m_pUIBuilder ? m_pUIBuilder->get<VclBox>("dialog-vbox1") : NULL;
571 : }
572 :
573 : // -----------------------------------------------------------------------
574 :
575 0 : Dialog::~Dialog()
576 : {
577 0 : maLayoutTimer.Stop();
578 0 : delete mpDialogImpl;
579 0 : mpDialogImpl = NULL;
580 0 : }
581 :
582 : // -----------------------------------------------------------------------
583 :
584 0 : IMPL_LINK_NOARG(Dialog, ImplAsyncCloseHdl)
585 : {
586 0 : Close();
587 0 : return 0;
588 : }
589 :
590 : // -----------------------------------------------------------------------
591 :
592 0 : long Dialog::Notify( NotifyEvent& rNEvt )
593 : {
594 : // Zuerst Basisklasse rufen wegen TabSteuerung
595 0 : long nRet = SystemWindow::Notify( rNEvt );
596 0 : if ( !nRet )
597 : {
598 0 : if ( rNEvt.GetType() == EVENT_KEYINPUT )
599 : {
600 0 : const KeyEvent* pKEvt = rNEvt.GetKeyEvent();
601 0 : KeyCode aKeyCode = pKEvt->GetKeyCode();
602 0 : sal_uInt16 nKeyCode = aKeyCode.GetCode();
603 :
604 0 : if ( (nKeyCode == KEY_ESCAPE) &&
605 0 : ((GetStyle() & WB_CLOSEABLE) || ImplGetCancelButton( this ) || ImplGetOKButton( this )) )
606 : {
607 : // #i89505# for the benefit of slightly mentally challenged implementations
608 : // like e.g. SfxModelessDialog which destroy themselves inside Close()
609 : // post this Close asynchronous so we can leave our key handler before
610 : // we get destroyed
611 0 : PostUserEvent( LINK( this, Dialog, ImplAsyncCloseHdl ), this );
612 0 : return sal_True;
613 : }
614 : }
615 0 : else if ( rNEvt.GetType() == EVENT_GETFOCUS )
616 : {
617 : // make sure the dialog is still modal
618 : // changing focus between application frames may
619 : // have re-enabled input for our parent
620 0 : if( mbInExecute && mbModalMode )
621 : {
622 : // do not change modal counter (pSVData->maAppData.mnModalDialog)
623 0 : SetModalInputMode( sal_False );
624 0 : SetModalInputMode( sal_True );
625 :
626 : // #93022# def-button might have changed after show
627 0 : if( !mnMousePositioned )
628 : {
629 0 : mnMousePositioned = 1;
630 0 : ImplMouseAutoPos( this );
631 : }
632 :
633 : }
634 : }
635 : }
636 :
637 0 : return nRet;
638 : }
639 :
640 0 : void Dialog::setInitialLayoutSize()
641 : {
642 0 : maLayoutTimer.Stop();
643 :
644 : //resize dialog to fit requisition on initial show
645 0 : VclBox *pBox = static_cast<VclBox*>(GetWindow(WINDOW_FIRSTCHILD));
646 :
647 : const DialogStyle& rDialogStyle =
648 0 : GetSettings().GetStyleSettings().GetDialogStyle();
649 0 : pBox->set_border_width(rDialogStyle.content_area_border);
650 0 : pBox->set_spacing(rDialogStyle.content_area_spacing);
651 :
652 0 : VclButtonBox *pActionArea = getActionArea(this);
653 0 : if (pActionArea)
654 : {
655 0 : pActionArea->set_border_width(rDialogStyle.action_area_border);
656 0 : pActionArea->set_spacing(rDialogStyle.button_spacing);
657 : }
658 :
659 0 : Size aSize = get_preferred_size();
660 :
661 0 : Size aMax = GetOptimalSize(WINDOWSIZE_MAXIMUM);
662 0 : aSize.Width() = std::min(aMax.Width(), aSize.Width());
663 0 : aSize.Height() = std::min(aMax.Height(), aSize.Height());
664 :
665 0 : SetMinOutputSizePixel(aSize);
666 0 : SetSizePixel(aSize);
667 0 : setPosSizeOnContainee(aSize, *pBox);
668 0 : }
669 :
670 : // -----------------------------------------------------------------------
671 :
672 0 : void Dialog::StateChanged( StateChangedType nType )
673 : {
674 0 : SystemWindow::StateChanged( nType );
675 :
676 0 : if ( nType == STATE_CHANGE_INITSHOW )
677 : {
678 0 : if (isLayoutEnabled())
679 0 : setInitialLayoutSize();
680 :
681 0 : if ( GetSettings().GetStyleSettings().GetAutoMnemonic() )
682 0 : ImplWindowAutoMnemonic( this );
683 :
684 0 : if ( !HasChildPathFocus() || HasFocus() )
685 0 : GrabFocusToFirstControl();
686 0 : if ( !(GetStyle() & WB_CLOSEABLE) )
687 : {
688 0 : if ( ImplGetCancelButton( this ) || ImplGetOKButton( this ) )
689 : {
690 0 : if ( ImplGetBorderWindow() )
691 0 : ((ImplBorderWindow*)ImplGetBorderWindow())->SetCloser();
692 : }
693 : }
694 :
695 0 : ImplMouseAutoPos( this );
696 : }
697 0 : else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
698 : {
699 0 : ImplInitSettings();
700 0 : Invalidate();
701 : }
702 0 : }
703 :
704 : // -----------------------------------------------------------------------
705 :
706 0 : void Dialog::DataChanged( const DataChangedEvent& rDCEvt )
707 : {
708 0 : SystemWindow::DataChanged( rDCEvt );
709 :
710 0 : if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
711 0 : (rDCEvt.GetFlags() & SETTINGS_STYLE) )
712 : {
713 0 : ImplInitSettings();
714 0 : Invalidate();
715 : }
716 0 : }
717 :
718 : // -----------------------------------------------------------------------
719 :
720 0 : sal_Bool Dialog::Close()
721 : {
722 0 : ImplDelData aDelData;
723 0 : ImplAddDel( &aDelData );
724 0 : ImplCallEventListeners( VCLEVENT_WINDOW_CLOSE );
725 0 : if ( aDelData.IsDead() )
726 0 : return sal_False;
727 0 : ImplRemoveDel( &aDelData );
728 :
729 0 : if ( mpWindowImpl->mxWindowPeer.is() && IsCreatedWithToolkit() && !IsInExecute() )
730 0 : return sal_False;
731 :
732 0 : mbInClose = sal_True;
733 :
734 0 : if ( !(GetStyle() & WB_CLOSEABLE) )
735 : {
736 0 : sal_Bool bRet = sal_True;
737 0 : ImplAddDel( &aDelData );
738 0 : PushButton* pButton = ImplGetCancelButton( this );
739 0 : if ( pButton )
740 0 : pButton->Click();
741 : else
742 : {
743 0 : pButton = ImplGetOKButton( this );
744 0 : if ( pButton )
745 0 : pButton->Click();
746 : else
747 0 : bRet = sal_False;
748 : }
749 0 : if ( aDelData.IsDead() )
750 0 : return sal_True;
751 0 : ImplRemoveDel( &aDelData );
752 0 : return bRet;
753 : }
754 :
755 0 : if ( IsInExecute() )
756 : {
757 0 : EndDialog( sal_False );
758 0 : mbInClose = sal_False;
759 0 : return sal_True;
760 : }
761 : else
762 : {
763 0 : mbInClose = sal_False;
764 0 : return SystemWindow::Close();
765 0 : }
766 : }
767 :
768 : // -----------------------------------------------------------------------
769 :
770 0 : sal_Bool Dialog::ImplStartExecuteModal()
771 : {
772 : #ifdef ANDROID
773 : // If a non-NativeActivity app, we shouldn't be showing any dialogs
774 : fprintf(stderr, "%s: Should not do anything, returning false\n", __FUNCTION__);
775 : return sal_False;
776 : #else
777 :
778 0 : if ( mbInExecute )
779 : {
780 : #ifdef DBG_UTIL
781 : rtl::OStringBuffer aErrorStr;
782 : aErrorStr.append(RTL_CONSTASCII_STRINGPARAM("Dialog::StartExecuteModal() is called in Dialog::StartExecuteModal(): "));
783 : aErrorStr.append(ImplGetDialogText(this));
784 : OSL_FAIL(aErrorStr.getStr());
785 : #endif
786 0 : return sal_False;
787 : }
788 :
789 0 : switch ( Application::GetDialogCancelMode() )
790 : {
791 : case Application::DIALOG_CANCEL_OFF:
792 0 : break;
793 : case Application::DIALOG_CANCEL_SILENT:
794 : SAL_INFO(
795 : "vcl",
796 : "Dialog \"" << ImplGetDialogText(this).getStr()
797 : << "\"cancelled in silent mode");
798 0 : return sal_False;
799 : default:
800 : assert(false); // this cannot happen
801 : // fall through
802 : case Application::DIALOG_CANCEL_FATAL:
803 : throw Application::DialogCancelledException(
804 0 : ImplGetDialogText(this).getStr());
805 : }
806 :
807 : #ifdef DBG_UTIL
808 : Window* pParent = GetParent();
809 : if ( pParent )
810 : {
811 : pParent = pParent->ImplGetFirstOverlapWindow();
812 : DBG_ASSERT( pParent->IsReallyVisible(),
813 : "Dialog::StartExecuteModal() - Parent not visible" );
814 : DBG_ASSERT( pParent->IsInputEnabled(),
815 : "Dialog::StartExecuteModal() - Parent input disabled, use another parent to ensure modality!" );
816 : DBG_ASSERT( ! pParent->IsInModalMode(),
817 : "Dialog::StartExecuteModal() - Parent already modally disabled, use another parent to ensure modality!" );
818 :
819 : }
820 : #endif
821 :
822 0 : ImplSVData* pSVData = ImplGetSVData();
823 :
824 : // Dialoge, die sich in Execute befinden, miteinander verketten
825 0 : mpPrevExecuteDlg = pSVData->maWinData.mpLastExecuteDlg;
826 0 : pSVData->maWinData.mpLastExecuteDlg = this;
827 :
828 : // Capture beenden, damit der Dialog bedient werden kann
829 0 : if ( pSVData->maWinData.mpTrackWin )
830 0 : pSVData->maWinData.mpTrackWin->EndTracking( ENDTRACK_CANCEL );
831 0 : if ( pSVData->maWinData.mpCaptureWin )
832 0 : pSVData->maWinData.mpCaptureWin->ReleaseMouse();
833 0 : EnableInput( sal_True, sal_True );
834 :
835 0 : if ( GetParent() )
836 : {
837 0 : NotifyEvent aNEvt( EVENT_EXECUTEDIALOG, this );
838 0 : GetParent()->Notify( aNEvt );
839 : }
840 0 : mbInExecute = sal_True;
841 0 : SetModalInputMode( sal_True );
842 0 : mbOldSaveBack = IsSaveBackgroundEnabled();
843 0 : EnableSaveBackground();
844 :
845 : // FIXME: no layouting, workaround some clipping issues
846 0 : ImplAdjustNWFSizes();
847 :
848 0 : Show();
849 :
850 0 : pSVData->maAppData.mnModalMode++;
851 0 : return sal_True;
852 : #endif
853 : }
854 :
855 : // -----------------------------------------------------------------------
856 :
857 0 : void Dialog::ImplEndExecuteModal()
858 : {
859 0 : ImplSVData* pSVData = ImplGetSVData();
860 0 : pSVData->maAppData.mnModalMode--;
861 0 : }
862 :
863 : // -----------------------------------------------------------------------
864 :
865 0 : short Dialog::Execute()
866 : {
867 0 : if ( !ImplStartExecuteModal() )
868 0 : return 0;
869 :
870 0 : ImplDelData aDelData;
871 0 : ImplAddDel( &aDelData );
872 :
873 : #ifdef DBG_UTIL
874 : ImplDelData aParentDelData;
875 : Window* pDialogParent = mpDialogParent;
876 : if( pDialogParent )
877 : pDialogParent->ImplAddDel( &aParentDelData );
878 : #endif
879 :
880 : // Yield util EndDialog is called or dialog gets destroyed
881 : // (the latter should not happen, but better safe than sorry
882 0 : while ( !aDelData.IsDead() && mbInExecute )
883 0 : Application::Yield();
884 :
885 0 : ImplEndExecuteModal();
886 :
887 : #ifdef DBG_UTIL
888 : if( pDialogParent )
889 : {
890 : if( ! aParentDelData.IsDead() )
891 : pDialogParent->ImplRemoveDel( &aParentDelData );
892 : else
893 : OSL_FAIL( "Dialog::Execute() - Parent of dialog destroyed in Execute()" );
894 : }
895 : #endif
896 0 : if ( !aDelData.IsDead() )
897 0 : ImplRemoveDel( &aDelData );
898 : #ifdef DBG_UTIL
899 : else
900 : {
901 : OSL_FAIL( "Dialog::Execute() - Dialog destroyed in Execute()" );
902 : }
903 : #endif
904 :
905 0 : long nRet = mpDialogImpl->mnResult;
906 0 : mpDialogImpl->mnResult = -1;
907 0 : return (short)nRet;
908 : }
909 :
910 : // -----------------------------------------------------------------------
911 :
912 : // virtual
913 0 : void Dialog::StartExecuteModal( const Link& rEndDialogHdl )
914 : {
915 0 : if ( !ImplStartExecuteModal() )
916 0 : return;
917 :
918 0 : mpDialogImpl->maEndDialogHdl = rEndDialogHdl;
919 0 : mpDialogImpl->mbStartedModal = true;
920 : }
921 :
922 : // -----------------------------------------------------------------------
923 :
924 0 : void Dialog::EndDialog( long nResult )
925 : {
926 0 : if ( mbInExecute )
927 : {
928 0 : SetModalInputMode( sal_False );
929 :
930 : // Dialog aus der Kette der Dialoge die in Execute stehen entfernen
931 0 : ImplSVData* pSVData = ImplGetSVData();
932 0 : Dialog* pExeDlg = pSVData->maWinData.mpLastExecuteDlg;
933 0 : while ( pExeDlg )
934 : {
935 0 : if ( pExeDlg == this )
936 : {
937 0 : pSVData->maWinData.mpLastExecuteDlg = mpPrevExecuteDlg;
938 0 : break;
939 : }
940 0 : pExeDlg = pExeDlg->mpPrevExecuteDlg;
941 : }
942 : // set focus to previous modal dialogue if it is modal for
943 : // the same frame parent (or NULL)
944 0 : if( mpPrevExecuteDlg )
945 : {
946 0 : Window* pFrameParent = ImplGetFrameWindow()->ImplGetParent();
947 0 : Window* pPrevFrameParent = mpPrevExecuteDlg->ImplGetFrameWindow()->ImplGetParent();
948 0 : if( ( !pFrameParent && !pPrevFrameParent ) ||
949 0 : ( pFrameParent && pPrevFrameParent && pFrameParent->ImplGetFrame() == pPrevFrameParent->ImplGetFrame() )
950 : )
951 : {
952 0 : mpPrevExecuteDlg->GrabFocus();
953 : }
954 : }
955 0 : mpPrevExecuteDlg = NULL;
956 :
957 0 : Hide();
958 0 : EnableSaveBackground( mbOldSaveBack );
959 0 : if ( GetParent() )
960 : {
961 0 : NotifyEvent aNEvt( EVENT_ENDEXECUTEDIALOG, this );
962 0 : GetParent()->Notify( aNEvt );
963 : }
964 :
965 0 : mpDialogImpl->mnResult = nResult;
966 :
967 0 : if ( mpDialogImpl->mbStartedModal )
968 : {
969 0 : ImplEndExecuteModal();
970 0 : mpDialogImpl->maEndDialogHdl.Call( this );
971 :
972 0 : mpDialogImpl->maEndDialogHdl = Link();
973 0 : mpDialogImpl->mbStartedModal = false;
974 0 : mpDialogImpl->mnResult = -1;
975 : }
976 0 : mbInExecute = sal_False;
977 : }
978 0 : }
979 :
980 : // -----------------------------------------------------------------------
981 :
982 0 : long Dialog::GetResult() const
983 : {
984 0 : return mpDialogImpl->mnResult;
985 : }
986 :
987 : // -----------------------------------------------------------------------
988 :
989 0 : void Dialog::EndAllDialogs( Window* pParent )
990 : {
991 0 : ImplSVData* pSVData = ImplGetSVData();
992 : Dialog* pTempModDialog;
993 0 : Dialog* pModDialog = pSVData->maWinData.mpLastExecuteDlg;
994 0 : while ( pModDialog )
995 : {
996 0 : pTempModDialog = pModDialog->mpPrevExecuteDlg;
997 0 : if( !pParent || ( pParent && pParent->IsWindowOrChild( pModDialog, sal_True ) ) )
998 : {
999 0 : pModDialog->EndDialog( sal_False );
1000 0 : pModDialog->PostUserEvent( Link() );
1001 : }
1002 0 : pModDialog = pTempModDialog;
1003 : }
1004 0 : }
1005 :
1006 : // -----------------------------------------------------------------------
1007 :
1008 0 : void Dialog::SetModalInputMode( sal_Bool bModal )
1009 : {
1010 0 : if ( bModal == mbModalMode )
1011 0 : return;
1012 :
1013 0 : ImplSVData* pSVData = ImplGetSVData();
1014 0 : mbModalMode = bModal;
1015 0 : if ( bModal )
1016 : {
1017 0 : pSVData->maAppData.mnModalDialog++;
1018 :
1019 : // Diable the prev Modal Dialog, because our dialog must close at first,
1020 : // before the other dialog can be closed (because the other dialog
1021 : // is on stack since our dialog returns)
1022 0 : if ( mpPrevExecuteDlg && !mpPrevExecuteDlg->IsWindowOrChild( this, sal_True ) )
1023 0 : mpPrevExecuteDlg->EnableInput( sal_False, sal_True, sal_True, this );
1024 :
1025 : // determine next overlap dialog parent
1026 0 : Window* pParent = GetParent();
1027 0 : if ( pParent )
1028 : {
1029 : // #103716# dialogs should always be modal to the whole frame window
1030 : // #115933# disable the whole frame hierarchie, useful if our parent
1031 : // is a modeless dialog
1032 0 : mpDialogParent = pParent->mpWindowImpl->mpFrameWindow;
1033 0 : mpDialogParent->ImplIncModalCount();
1034 : }
1035 :
1036 : }
1037 : else
1038 : {
1039 0 : pSVData->maAppData.mnModalDialog--;
1040 :
1041 0 : if ( mpDialogParent )
1042 : {
1043 : // #115933# re-enable the whole frame hierarchie again (see above)
1044 : // note that code in getfocus assures that we do not accidentally enable
1045 : // windows that were disabled before
1046 0 : mpDialogParent->ImplDecModalCount();
1047 : }
1048 :
1049 : // Enable the prev Modal Dialog
1050 0 : if ( mpPrevExecuteDlg && !mpPrevExecuteDlg->IsWindowOrChild( this, sal_True ) )
1051 : {
1052 0 : mpPrevExecuteDlg->EnableInput( sal_True, sal_True, sal_True, this );
1053 : // ensure continued modality of prev dialog
1054 : // do not change modality counter
1055 0 : mpPrevExecuteDlg->SetModalInputMode( sal_False );
1056 0 : mpPrevExecuteDlg->SetModalInputMode( sal_True );
1057 : }
1058 : }
1059 : }
1060 :
1061 : // -----------------------------------------------------------------------
1062 :
1063 0 : void Dialog::SetModalInputMode( sal_Bool bModal, sal_Bool bSubModalDialogs )
1064 : {
1065 0 : if ( bSubModalDialogs )
1066 : {
1067 0 : Window* pOverlap = ImplGetFirstOverlapWindow();
1068 0 : pOverlap = pOverlap->mpWindowImpl->mpFirstOverlap;
1069 0 : while ( pOverlap )
1070 : {
1071 0 : if ( pOverlap->IsDialog() )
1072 0 : ((Dialog*)pOverlap)->SetModalInputMode( bModal, sal_True );
1073 0 : pOverlap = pOverlap->mpWindowImpl->mpNext;
1074 : }
1075 : }
1076 :
1077 0 : SetModalInputMode( bModal );
1078 0 : }
1079 :
1080 : // -----------------------------------------------------------------------
1081 :
1082 0 : void Dialog::GrabFocusToFirstControl()
1083 : {
1084 : Window* pFocusControl;
1085 :
1086 : // Wenn Dialog den Focus hat, versuchen wr trotzdem
1087 : // ein Focus-Control zu finden
1088 0 : if ( HasFocus() )
1089 0 : pFocusControl = NULL;
1090 : else
1091 : {
1092 : // Wenn schon ein Child-Fenster mal den Focus hatte,
1093 : // dann dieses bevorzugen
1094 0 : pFocusControl = ImplGetFirstOverlapWindow()->mpWindowImpl->mpLastFocusWindow;
1095 : // Control aus der Dialog-Steuerung suchen
1096 0 : if ( pFocusControl )
1097 0 : pFocusControl = ImplFindDlgCtrlWindow( pFocusControl );
1098 : }
1099 : // Kein Control hatte vorher den Focus, oder das Control
1100 : // befindet sich nicht in der Tab-Steuerung, dann das erste
1101 : // Control in der TabSteuerung den Focus geben
1102 0 : if ( !pFocusControl ||
1103 0 : !(pFocusControl->GetStyle() & WB_TABSTOP) ||
1104 0 : !isVisibleInLayout(pFocusControl) ||
1105 0 : !isEnabledInLayout(pFocusControl) || !pFocusControl->IsInputEnabled() )
1106 : {
1107 0 : sal_uInt16 n = 0;
1108 0 : pFocusControl = ImplGetDlgWindow( n, DLGWINDOW_FIRST );
1109 : }
1110 0 : if ( pFocusControl )
1111 0 : pFocusControl->ImplControlFocus( GETFOCUS_INIT );
1112 0 : }
1113 :
1114 0 : void Dialog::GetDrawWindowBorder( sal_Int32& rLeftBorder, sal_Int32& rTopBorder, sal_Int32& rRightBorder, sal_Int32& rBottomBorder ) const
1115 : {
1116 0 : ImplBorderWindow aImplWin( (Window*)this, WB_BORDER|WB_STDWORK, BORDERWINDOW_STYLE_OVERLAP );
1117 : // aImplWin.SetText( GetText() );
1118 : // aImplWin.SetPosSizePixel( aPos.X(), aPos.Y(), aSize.Width(), aSize.Height() );
1119 : // aImplWin.SetDisplayActive( sal_True );
1120 : // aImplWin.InitView();
1121 0 : aImplWin.GetBorder( rLeftBorder, rTopBorder, rRightBorder, rBottomBorder );
1122 0 : }
1123 :
1124 :
1125 0 : void Dialog::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, sal_uLong )
1126 : {
1127 0 : Point aPos = pDev->LogicToPixel( rPos );
1128 0 : Size aSize = pDev->LogicToPixel( rSize );
1129 :
1130 0 : Wallpaper aWallpaper = GetBackground();
1131 0 : if ( !aWallpaper.IsBitmap() )
1132 0 : ImplInitSettings();
1133 :
1134 0 : pDev->Push();
1135 0 : pDev->SetMapMode();
1136 0 : pDev->SetLineColor();
1137 :
1138 0 : if ( aWallpaper.IsBitmap() )
1139 0 : pDev->DrawBitmapEx( aPos, aSize, aWallpaper.GetBitmap() );
1140 : else
1141 : {
1142 0 : pDev->SetFillColor( aWallpaper.GetColor() );
1143 0 : pDev->DrawRect( Rectangle( aPos, aSize ) );
1144 : }
1145 :
1146 0 : if (!( GetStyle() & WB_NOBORDER ))
1147 : {
1148 0 : ImplBorderWindow aImplWin( this, WB_BORDER|WB_STDWORK, BORDERWINDOW_STYLE_OVERLAP );
1149 0 : aImplWin.SetText( GetText() );
1150 0 : aImplWin.setPosSizePixel( aPos.X(), aPos.Y(), aSize.Width(), aSize.Height() );
1151 0 : aImplWin.SetDisplayActive( sal_True );
1152 0 : aImplWin.InitView();
1153 :
1154 0 : aImplWin.Draw( Rectangle( aPos, aSize ), pDev, aPos );
1155 : }
1156 :
1157 0 : pDev->Pop();
1158 0 : }
1159 :
1160 0 : bool Dialog::isLayoutEnabled() const
1161 : {
1162 : //pre dtor called, and single child is a container => we're layout enabled
1163 0 : const Window *pChild = mpDialogImpl ? GetWindow(WINDOW_FIRSTCHILD) : NULL;
1164 0 : return pChild && isContainerWindow(*pChild) && !pChild->GetWindow(WINDOW_NEXT);
1165 : }
1166 :
1167 0 : Size Dialog::GetOptimalSize(WindowSizeType eType) const
1168 : {
1169 0 : if (eType == WINDOWSIZE_MAXIMUM || !isLayoutEnabled())
1170 0 : return SystemWindow::GetOptimalSize(eType);
1171 :
1172 0 : Size aSize = VclContainer::getLayoutRequisition(*GetWindow(WINDOW_FIRSTCHILD));
1173 :
1174 0 : sal_Int32 nBorderWidth = get_border_width();
1175 :
1176 0 : aSize.Height() += mpWindowImpl->mnLeftBorder + mpWindowImpl->mnRightBorder
1177 0 : + 2*nBorderWidth;
1178 0 : aSize.Width() += mpWindowImpl->mnTopBorder + mpWindowImpl->mnBottomBorder
1179 0 : + 2*nBorderWidth;
1180 :
1181 0 : return Window::CalcWindowSize(aSize);
1182 : }
1183 :
1184 0 : void Dialog::setPosSizeOnContainee(Size aSize, VclContainer &rBox)
1185 : {
1186 0 : sal_Int32 nBorderWidth = get_border_width();
1187 :
1188 0 : aSize.Width() -= mpWindowImpl->mnLeftBorder + mpWindowImpl->mnRightBorder
1189 0 : + 2 * nBorderWidth;
1190 0 : aSize.Height() -= mpWindowImpl->mnTopBorder + mpWindowImpl->mnBottomBorder
1191 0 : + 2 * nBorderWidth;
1192 :
1193 : Point aPos(mpWindowImpl->mnLeftBorder + nBorderWidth,
1194 0 : mpWindowImpl->mnTopBorder + nBorderWidth);
1195 :
1196 0 : VclContainer::setLayoutAllocation(rBox, aPos, aSize);
1197 0 : }
1198 :
1199 0 : IMPL_LINK( Dialog, ImplHandleLayoutTimerHdl, void*, EMPTYARG )
1200 : {
1201 0 : if (!isLayoutEnabled())
1202 : {
1203 : SAL_WARN("vcl.layout", "Dialog has become non-layout because extra children have been added directly to it.");
1204 0 : return 0;
1205 : }
1206 :
1207 0 : VclBox *pBox = static_cast<VclBox*>(GetWindow(WINDOW_FIRSTCHILD));
1208 : assert(pBox);
1209 0 : setPosSizeOnContainee(GetSizePixel(), *pBox);
1210 0 : return 0;
1211 : }
1212 :
1213 0 : void Dialog::queue_layout()
1214 : {
1215 0 : if (hasPendingLayout())
1216 0 : return;
1217 0 : if (IsInClose())
1218 0 : return;
1219 0 : if (!isLayoutEnabled())
1220 0 : return;
1221 0 : maLayoutTimer.Start();
1222 : }
1223 :
1224 0 : void Dialog::Resize()
1225 : {
1226 0 : queue_layout();
1227 0 : }
1228 :
1229 0 : bool Dialog::set_property(const rtl::OString &rKey, const rtl::OString &rValue)
1230 : {
1231 0 : if (rKey.equalsL(RTL_CONSTASCII_STRINGPARAM("border-width")))
1232 0 : set_border_width(rValue.toInt32());
1233 : else
1234 0 : return SystemWindow::set_property(rKey, rValue);
1235 0 : return true;
1236 : }
1237 :
1238 0 : VclBuilderContainer::VclBuilderContainer()
1239 0 : : m_pUIBuilder(NULL)
1240 : {
1241 0 : }
1242 :
1243 0 : VclBuilderContainer::~VclBuilderContainer()
1244 : {
1245 0 : delete m_pUIBuilder;
1246 0 : }
1247 :
1248 : // -----------------------------------------------------------------------
1249 :
1250 0 : ModelessDialog::ModelessDialog( Window* pParent, const ResId& rResId ) :
1251 0 : Dialog( WINDOW_MODELESSDIALOG )
1252 : {
1253 0 : rResId.SetRT( RSC_MODELESSDIALOG );
1254 :
1255 0 : WinBits nStyle = init( pParent, rResId );
1256 :
1257 0 : if ( !(nStyle & WB_HIDE) )
1258 0 : Show();
1259 0 : }
1260 :
1261 0 : ModelessDialog::ModelessDialog( Window* pParent, const rtl::OString& rID, const rtl::OUString& rUIXMLDescription ) :
1262 0 : Dialog(pParent, rID, rUIXMLDescription, WINDOW_MODELESSDIALOG)
1263 : {
1264 0 : }
1265 :
1266 : // =======================================================================
1267 :
1268 0 : ModalDialog::ModalDialog( Window* pParent, WinBits nStyle ) :
1269 0 : Dialog( WINDOW_MODALDIALOG )
1270 : {
1271 0 : ImplInit( pParent, nStyle );
1272 0 : }
1273 :
1274 : // -----------------------------------------------------------------------
1275 :
1276 0 : ModalDialog::ModalDialog( Window* pParent, const ResId& rResId ) :
1277 0 : Dialog( WINDOW_MODALDIALOG )
1278 : {
1279 0 : rResId.SetRT( RSC_MODALDIALOG );
1280 0 : init( pParent, rResId );
1281 0 : }
1282 :
1283 0 : ModalDialog::ModalDialog( Window* pParent, const rtl::OString& rID, const rtl::OUString& rUIXMLDescription ) :
1284 0 : Dialog(pParent, rID, rUIXMLDescription, WINDOW_MODALDIALOG)
1285 : {
1286 108 : }
1287 :
1288 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
