vcl/source/window/dialog.cxx

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