vcl/source/app/weldutils.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
  10 #include <com/sun/star/util/URLTransformer.hpp>
  11 #include <com/sun/star/frame/Desktop.hpp>
  12 #include <comphelper/processfactory.hxx>
  13 #include <svl/numformat.hxx>
  14 #include <svl/zforlist.hxx>
  15 #include <svl/zformat.hxx>
  16 #include <vcl/builderpage.hxx>
  17 #include <vcl/commandevent.hxx>
  18 #include <vcl/commandinfoprovider.hxx>
  19 #include <vcl/event.hxx>
  20 #include <vcl/toolkit/floatwin.hxx>
  21 #include <vcl/settings.hxx>
  22 #include <vcl/svapp.hxx>
  23 #include <vcl/weldutils.hxx>
  24
  25 BuilderPage::BuilderPage(weld::Widget* pParent, weld::DialogController* pController,
  26                          const OUString& rUIXMLDescription, const OUString& rID, bool bIsMobile)
  27     : m_pDialogController(pController)
  28     , m_xBuilder(Application::CreateBuilder(pParent, rUIXMLDescription, bIsMobile))
  29     , m_xContainer(m_xBuilder->weld_container(rID))
  30 {
  31 }
  32
  33 void BuilderPage::Activate() {}
  34
  35 void BuilderPage::Deactivate() {}
  36
  37 BuilderPage::~BuilderPage() COVERITY_NOEXCEPT_FALSE {}
  38
  39 namespace weld
  40 {
  41 bool DialogController::runAsync(const std::shared_ptr<DialogController>& rController,
  42                                 const std::function<void(sal_Int32)>& func)
  43 {
  44     return rController->getDialog()->runAsync(rController, func);
  45 }
  46
  47 DialogController::~DialogController() COVERITY_NOEXCEPT_FALSE {}
  48
  49 Dialog* GenericDialogController::getDialog() { return m_xDialog.get(); }
  50
  51 GenericDialogController::GenericDialogController(weld::Widget* pParent, const OUString& rUIFile,
  52                                                  const OUString& rDialogId, bool bMobile)
  53     : m_xBuilder(Application::CreateBuilder(pParent, rUIFile, bMobile))
  54     , m_xDialog(m_xBuilder->weld_dialog(rDialogId))
  55 {
  56 }
  57
  58 GenericDialogController::~GenericDialogController() COVERITY_NOEXCEPT_FALSE {}
  59
  60 Dialog* MessageDialogController::getDialog() { return m_xDialog.get(); }
  61
  62 MessageDialogController::MessageDialogController(weld::Widget* pParent, const OUString& rUIFile,
  63                                                  const OUString& rDialogId,
  64                                                  const OUString& rRelocateId)
  65     : m_xBuilder(Application::CreateBuilder(pParent, rUIFile))
  66     , m_xDialog(m_xBuilder->weld_message_dialog(rDialogId))
  67     , m_xContentArea(m_xDialog->weld_message_area())
  68 {
  69     if (!rRelocateId.isEmpty())
  70     {
  71         m_xRelocate = m_xBuilder->weld_container(rRelocateId);
  72         m_xOrigParent = m_xRelocate->weld_parent();
  73         //fdo#75121, a bit tricky because the widgets we want to align with
  74         //don't actually exist in the ui description, they're implied
  75         m_xOrigParent->move(m_xRelocate.get(), m_xContentArea.get());
  76     }
  77 }
  78
  79 MessageDialogController::~MessageDialogController()
  80 {
  81     if (m_xRelocate)
  82     {
  83         m_xContentArea->move(m_xRelocate.get(), m_xOrigParent.get());
  84     }
  85 }
  86
  87 AssistantController::AssistantController(weld::Widget* pParent, const OUString& rUIFile,
  88                                          const OUString& rDialogId)
  89     : m_xBuilder(Application::CreateBuilder(pParent, rUIFile))
  90     , m_xAssistant(m_xBuilder->weld_assistant(rDialogId))
  91 {
  92 }
  93
  94 Dialog* AssistantController::getDialog() { return m_xAssistant.get(); }
  95
  96 AssistantController::~AssistantController() {}
  97
  98 void TriStateEnabled::ButtonToggled(weld::Toggleable& rToggle)
  99 {
 100     if (bTriStateEnabled)
 101     {
 102         switch (eState)
 103         {
 104             case TRISTATE_INDET:
 105                 rToggle.set_state(TRISTATE_FALSE);
 106                 break;
 107             case TRISTATE_TRUE:
 108                 rToggle.set_state(TRISTATE_INDET);
 109                 break;
 110             case TRISTATE_FALSE:
 111                 rToggle.set_state(TRISTATE_TRUE);
 112                 break;
 113         }
 114     }
 115     eState = rToggle.get_state();
 116 }
 117
 118 void RemoveParentKeepChildren(weld::TreeView& rTreeView, const weld::TreeIter& rParent)
 119 {
 120     if (rTreeView.iter_has_child(rParent))
 121     {
 122         std::unique_ptr<weld::TreeIter> xNewParent(rTreeView.make_iterator(&rParent));
 123         if (!rTreeView.iter_parent(*xNewParent))
 124             xNewParent.reset();
 125
 126         while (true)
 127         {
 128             std::unique_ptr<weld::TreeIter> xChild(rTreeView.make_iterator(&rParent));
 129             if (!rTreeView.iter_children(*xChild))
 130                 break;
 131             rTreeView.move_subtree(*xChild, xNewParent.get(), -1);
 132         }
 133     }
 134     rTreeView.remove(rParent);
 135 }
 136
 137 EntryFormatter::EntryFormatter(weld::FormattedSpinButton& rSpinButton)
 138     : m_rEntry(rSpinButton)
 139     , m_pSpinButton(&rSpinButton)
 140     , m_eOptions(Application::GetSettings().GetStyleSettings().GetSelectionOptions())
 141 {
 142     Init();
 143 }
 144
 145 EntryFormatter::EntryFormatter(weld::Entry& rEntry)
 146     : m_rEntry(rEntry)
 147     , m_pSpinButton(nullptr)
 148     , m_eOptions(Application::GetSettings().GetStyleSettings().GetSelectionOptions())
 149 {
 150     Init();
 151 }
 152
 153 EntryFormatter::~EntryFormatter()
 154 {
 155     m_rEntry.connect_changed(Link<weld::Entry&, void>());
 156     m_rEntry.connect_focus_out(Link<weld::Widget&, void>());
 157     if (m_pSpinButton)
 158         m_pSpinButton->SetFormatter(nullptr);
 159 }
 160
 161 void EntryFormatter::Init()
 162 {
 163     m_rEntry.connect_changed(LINK(this, EntryFormatter, ModifyHdl));
 164     m_rEntry.connect_focus_out(LINK(this, EntryFormatter, FocusOutHdl));
 165     if (m_pSpinButton)
 166         m_pSpinButton->SetFormatter(this);
 167 }
 168
 169 Selection EntryFormatter::GetEntrySelection() const
 170 {
 171     int nStartPos, nEndPos;
 172     m_rEntry.get_selection_bounds(nStartPos, nEndPos);
 173     return Selection(nStartPos, nEndPos);
 174 }
 175
 176 OUString EntryFormatter::GetEntryText() const { return m_rEntry.get_text(); }
 177
 178 void EntryFormatter::SetEntryText(const OUString& rText, const Selection& rSel)
 179 {
 180     m_rEntry.set_text(rText);
 181     auto nMin = rSel.Min();
 182     auto nMax = rSel.Max();
 183     m_rEntry.select_region(nMin < 0 ? 0 : nMin, nMax == SELECTION_MAX ? -1 : nMax);
 184 }
 185
 186 void EntryFormatter::SetEntryTextColor(const Color* pColor)
 187 {
 188     m_rEntry.set_font_color(pColor ? *pColor : COL_AUTO);
 189 }
 190
 191 void EntryFormatter::UpdateCurrentValue(double dCurrentValue)
 192 {
 193     Formatter::UpdateCurrentValue(dCurrentValue);
 194     if (m_pSpinButton)
 195         m_pSpinButton->sync_value_from_formatter();
 196 }
 197
 198 void EntryFormatter::ClearMinValue()
 199 {
 200     Formatter::ClearMinValue();
 201     if (m_pSpinButton)
 202         m_pSpinButton->sync_range_from_formatter();
 203 }
 204
 205 void EntryFormatter::SetMinValue(double dMin)
 206 {
 207     Formatter::SetMinValue(dMin);
 208     if (m_pSpinButton)
 209         m_pSpinButton->sync_range_from_formatter();
 210 }
 211
 212 void EntryFormatter::ClearMaxValue()
 213 {
 214     Formatter::ClearMaxValue();
 215     if (m_pSpinButton)
 216         m_pSpinButton->sync_range_from_formatter();
 217 }
 218
 219 void EntryFormatter::SetMaxValue(double dMin)
 220 {
 221     Formatter::SetMaxValue(dMin);
 222     if (m_pSpinButton)
 223         m_pSpinButton->sync_range_from_formatter();
 224 }
 225
 226 void EntryFormatter::SetSpinSize(double dStep)
 227 {
 228     Formatter::SetSpinSize(dStep);
 229     if (m_pSpinButton)
 230         m_pSpinButton->sync_increments_from_formatter();
 231 }
 232
 233 SelectionOptions EntryFormatter::GetEntrySelectionOptions() const { return m_eOptions; }
 234
 235 void EntryFormatter::FieldModified() { m_aModifyHdl.Call(m_rEntry); }
 236
 237 IMPL_LINK_NOARG(EntryFormatter, ModifyHdl, weld::Entry&, void)
 238 {
 239     // This leads to FieldModified getting called at the end of Modify() and
 240     // FieldModified then calls any modification callback
 241     Modify();
 242 }
 243
 244 IMPL_LINK_NOARG(EntryFormatter, FocusOutHdl, weld::Widget&, void)
 245 {
 246     EntryLostFocus();
 247     if (m_pSpinButton)
 248         m_pSpinButton->signal_value_changed();
 249     m_aFocusOutHdl.Call(m_rEntry);
 250 }
 251
 252 DoubleNumericFormatter::DoubleNumericFormatter(weld::Entry& rEntry)
 253     : EntryFormatter(rEntry)
 254 {
 255     ResetConformanceTester();
 256 }
 257
 258 DoubleNumericFormatter::DoubleNumericFormatter(weld::FormattedSpinButton& rSpinButton)
 259     : EntryFormatter(rSpinButton)
 260 {
 261     ResetConformanceTester();
 262 }
 263
 264 DoubleNumericFormatter::~DoubleNumericFormatter() = default;
 265
 266 void DoubleNumericFormatter::FormatChanged(FORMAT_CHANGE_TYPE nWhat)
 267 {
 268     ResetConformanceTester();
 269     EntryFormatter::FormatChanged(nWhat);
 270 }
 271
 272 bool DoubleNumericFormatter::CheckText(const OUString& sText) const
 273 {
 274     // We'd like to implement this using the NumberFormatter::IsNumberFormat, but unfortunately, this doesn't
 275     // recognize fragments of numbers (like, for instance "1e", which happens during entering e.g. "1e10")
 276     // Thus, the roundabout way via a regular expression
 277     return m_pNumberValidator->isValidNumericFragment(sText);
 278 }
 279
 280 void DoubleNumericFormatter::ResetConformanceTester()
 281 {
 282     // the thousands and the decimal separator are language dependent
 283     const SvNumberformat* pFormatEntry = GetOrCreateFormatter()->GetEntry(m_nFormatKey);
 284
 285     sal_Unicode cSeparatorThousand = ',';
 286     sal_Unicode cSeparatorDecimal = '.';
 287     if (pFormatEntry)
 288     {
 289         LocaleDataWrapper aLocaleInfo(LanguageTag(pFormatEntry->GetLanguage()));
 290
 291         OUString sSeparator = aLocaleInfo.getNumThousandSep();
 292         if (!sSeparator.isEmpty())
 293             cSeparatorThousand = sSeparator[0];
 294
 295         sSeparator = aLocaleInfo.getNumDecimalSep();
 296         if (!sSeparator.isEmpty())
 297             cSeparatorDecimal = sSeparator[0];
 298     }
 299
 300     m_pNumberValidator.reset(
 301         new validation::NumberValidator(cSeparatorThousand, cSeparatorDecimal));
 302 }
 303
 304 LongCurrencyFormatter::LongCurrencyFormatter(weld::Entry& rEntry)
 305     : EntryFormatter(rEntry)
 306     , m_bThousandSep(true)
 307 {
 308     Init();
 309 }
 310
 311 LongCurrencyFormatter::LongCurrencyFormatter(weld::FormattedSpinButton& rSpinButton)
 312     : EntryFormatter(rSpinButton)
 313     , m_bThousandSep(true)
 314 {
 315     Init();
 316 }
 317
 318 void LongCurrencyFormatter::Init()
 319 {
 320     SetOutputHdl(LINK(this, LongCurrencyFormatter, FormatOutputHdl));
 321     SetInputHdl(LINK(this, LongCurrencyFormatter, ParseInputHdl));
 322 }
 323
 324 void LongCurrencyFormatter::SetUseThousandSep(bool b)
 325 {
 326     m_bThousandSep = b;
 327     ReFormat();
 328 }
 329
 330 void LongCurrencyFormatter::SetCurrencySymbol(const OUString& rStr)
 331 {
 332     m_aCurrencySymbol = rStr;
 333     ReFormat();
 334 }
 335
 336 LongCurrencyFormatter::~LongCurrencyFormatter() = default;
 337
 338 TimeFormatter::TimeFormatter(weld::Entry& rEntry)
 339     : EntryFormatter(rEntry)
 340     , m_eFormat(TimeFieldFormat::F_NONE)
 341     , m_eTimeFormat(TimeFormat::Hour24)
 342     , m_bDuration(false)
 343 {
 344     Init();
 345 }
 346
 347 TimeFormatter::TimeFormatter(weld::FormattedSpinButton& rSpinButton)
 348     : EntryFormatter(rSpinButton)
 349     , m_eFormat(TimeFieldFormat::F_NONE)
 350     , m_eTimeFormat(TimeFormat::Hour24)
 351     , m_bDuration(false)
 352 {
 353     Init();
 354 }
 355
 356 void TimeFormatter::Init()
 357 {
 358     DisableRemainderFactor(); //so with hh::mm::ss, incrementing mm will not reset ss
 359
 360     SetOutputHdl(LINK(this, TimeFormatter, FormatOutputHdl));
 361     SetInputHdl(LINK(this, TimeFormatter, ParseInputHdl));
 362
 363     SetMin(tools::Time(0, 0));
 364     SetMax(tools::Time(23, 59, 59, 999999999));
 365
 366     // so the spin size can depend on which zone the cursor is in
 367     get_widget().connect_cursor_position(LINK(this, TimeFormatter, CursorChangedHdl));
 368     // and set the initial spin size
 369     CursorChangedHdl(get_widget());
 370 }
 371
 372 void TimeFormatter::SetExtFormat(ExtTimeFieldFormat eFormat)
 373 {
 374     switch (eFormat)
 375     {
 376         case ExtTimeFieldFormat::Short24H:
 377         {
 378             m_eTimeFormat = TimeFormat::Hour24;
 379             m_bDuration = false;
 380             m_eFormat = TimeFieldFormat::F_NONE;
 381         }
 382         break;
 383         case ExtTimeFieldFormat::Long24H:
 384         {
 385             m_eTimeFormat = TimeFormat::Hour24;
 386             m_bDuration = false;
 387             m_eFormat = TimeFieldFormat::F_SEC;
 388         }
 389         break;
 390         case ExtTimeFieldFormat::Short12H:
 391         {
 392             m_eTimeFormat = TimeFormat::Hour12;
 393             m_bDuration = false;
 394             m_eFormat = TimeFieldFormat::F_NONE;
 395         }
 396         break;
 397         case ExtTimeFieldFormat::Long12H:
 398         {
 399             m_eTimeFormat = TimeFormat::Hour12;
 400             m_bDuration = false;
 401             m_eFormat = TimeFieldFormat::F_SEC;
 402         }
 403         break;
 404         case ExtTimeFieldFormat::ShortDuration:
 405         {
 406             m_bDuration = true;
 407             m_eFormat = TimeFieldFormat::F_NONE;
 408         }
 409         break;
 410         case ExtTimeFieldFormat::LongDuration:
 411         {
 412             m_bDuration = true;
 413             m_eFormat = TimeFieldFormat::F_SEC;
 414         }
 415         break;
 416     }
 417
 418     ReFormat();
 419 }
 420
 421 void TimeFormatter::SetDuration(bool bDuration)
 422 {
 423     m_bDuration = bDuration;
 424     ReFormat();
 425 }
 426
 427 void TimeFormatter::SetTimeFormat(TimeFieldFormat eTimeFormat)
 428 {
 429     m_eFormat = eTimeFormat;
 430     ReFormat();
 431 }
 432
 433 TimeFormatter::~TimeFormatter() = default;
 434
 435 DateFormatter::DateFormatter(weld::Entry& rEntry)
 436     : EntryFormatter(rEntry)
 437     , m_eFormat(ExtDateFieldFormat::SystemShort)
 438 {
 439     Init();
 440 }
 441
 442 void DateFormatter::Init()
 443 {
 444     SetOutputHdl(LINK(this, DateFormatter, FormatOutputHdl));
 445     SetInputHdl(LINK(this, DateFormatter, ParseInputHdl));
 446
 447     SetMin(Date(1, 1, 1900));
 448     SetMax(Date(31, 12, 2200));
 449 }
 450
 451 void DateFormatter::SetExtDateFormat(ExtDateFieldFormat eFormat)
 452 {
 453     m_eFormat = eFormat;
 454     ReFormat();
 455 }
 456
 457 DateFormatter::~DateFormatter() = default;
 458
 459 PatternFormatter::PatternFormatter(weld::Entry& rEntry)
 460     : m_rEntry(rEntry)
 461     , m_bStrictFormat(false)
 462     , m_bSameMask(true)
 463     , m_bReformat(false)
 464     , m_bInPattKeyInput(false)
 465 {
 466     m_rEntry.connect_changed(LINK(this, PatternFormatter, ModifyHdl));
 467     m_rEntry.connect_focus_in(LINK(this, PatternFormatter, FocusInHdl));
 468     m_rEntry.connect_focus_out(LINK(this, PatternFormatter, FocusOutHdl));
 469     m_rEntry.connect_key_press(LINK(this, PatternFormatter, KeyInputHdl));
 470 }
 471
 472 IMPL_LINK_NOARG(PatternFormatter, ModifyHdl, weld::Entry&, void) { Modify(); }
 473
 474 IMPL_LINK_NOARG(PatternFormatter, FocusOutHdl, weld::Widget&, void)
 475 {
 476     EntryLostFocus();
 477     m_aFocusOutHdl.Call(m_rEntry);
 478 }
 479
 480 IMPL_LINK_NOARG(PatternFormatter, FocusInHdl, weld::Widget&, void)
 481 {
 482     EntryGainFocus();
 483     m_aFocusInHdl.Call(m_rEntry);
 484 }
 485
 486 PatternFormatter::~PatternFormatter()
 487 {
 488     m_rEntry.connect_changed(Link<weld::Entry&, void>());
 489     m_rEntry.connect_focus_out(Link<weld::Widget&, void>());
 490 }
 491
 492 WidgetStatusListener::WidgetStatusListener(weld::Widget* widget, const OUString& aCommand)
 493     : mWidget(widget)
 494 {
 495     const css::uno::Reference<css::uno::XComponentContext>& xContext
 496         = ::comphelper::getProcessComponentContext();
 497     css::uno::Reference<css::frame::XDesktop2> xDesktop = css::frame::Desktop::create(xContext);
 498
 499     css::uno::Reference<css::frame::XFrame> xFrame(xDesktop->getActiveFrame());
 500     if (!xFrame.is())
 501         xFrame = xDesktop;
 502
 503     mxFrame = std::move(xFrame);
 504
 505     maCommandURL.Complete = aCommand;
 506     css::uno::Reference<css::util::XURLTransformer> xParser
 507         = css::util::URLTransformer::create(xContext);
 508     xParser->parseStrict(maCommandURL);
 509 }
 510
 511 void WidgetStatusListener::startListening()
 512 {
 513     if (mxDispatch.is())
 514         mxDispatch->removeStatusListener(this, maCommandURL);
 515
 516     css::uno::Reference<css::frame::XDispatchProvider> xDispatchProvider(mxFrame,
 517                                                                          css::uno::UNO_QUERY);
 518     if (!xDispatchProvider.is())
 519         return;
 520
 521     mxDispatch = xDispatchProvider->queryDispatch(maCommandURL, u""_ustr, 0);
 522     if (mxDispatch.is())
 523         mxDispatch->addStatusListener(this, maCommandURL);
 524 }
 525
 526 void WidgetStatusListener::statusChanged(const css::frame::FeatureStateEvent& rEvent)
 527 {
 528     mWidget->set_sensitive(rEvent.IsEnabled);
 529 }
 530
 531 void WidgetStatusListener::disposing(const css::lang::EventObject& /*Source*/)
 532 {
 533     mxDispatch.clear();
 534 }
 535
 536 void WidgetStatusListener::dispose()
 537 {
 538     if (mxDispatch.is())
 539     {
 540         mxDispatch->removeStatusListener(this, maCommandURL);
 541         mxDispatch.clear();
 542     }
 543     mxFrame.clear();
 544     mWidget = nullptr;
 545 }
 546
 547 ButtonPressRepeater::ButtonPressRepeater(weld::Button& rButton, const Link<Button&, void>& rLink,
 548                                          const Link<const CommandEvent&, void>& rContextLink)
 549     : m_rButton(rButton)
 550     , m_aRepeat("vcl ButtonPressRepeater m_aRepeat")
 551     , m_aLink(rLink)
 552     , m_aContextLink(rContextLink)
 553     , m_bModKey(false)
 554 {
 555     // instead of connect_clicked because we want a button held down to
 556     // repeat the next/prev
 557     m_rButton.connect_mouse_press(LINK(this, ButtonPressRepeater, MousePressHdl));
 558     m_rButton.connect_mouse_release(LINK(this, ButtonPressRepeater, MouseReleaseHdl));
 559
 560     m_aRepeat.SetInvokeHandler(LINK(this, ButtonPressRepeater, RepeatTimerHdl));
 561 }
 562
 563 IMPL_LINK(ButtonPressRepeater, MousePressHdl, const MouseEvent&, rMouseEvent, bool)
 564 {
 565     if (rMouseEvent.IsRight())
 566     {
 567         m_aContextLink.Call(
 568             CommandEvent(rMouseEvent.GetPosPixel(), CommandEventId::ContextMenu, true));
 569         return false;
 570     }
 571     m_bModKey = rMouseEvent.IsMod1();
 572     if (!m_rButton.get_sensitive())
 573         return false;
 574     auto self = weak_from_this();
 575     RepeatTimerHdl(nullptr);
 576     if (!self.lock())
 577         return false;
 578     if (!m_rButton.get_sensitive())
 579         return false;
 580     m_aRepeat.SetTimeout(MouseSettings::GetButtonStartRepeat());
 581     m_aRepeat.Start();
 582     return true;
 583 }
 584
 585 IMPL_LINK_NOARG(ButtonPressRepeater, MouseReleaseHdl, const MouseEvent&, bool)
 586 {
 587     m_bModKey = false;
 588     m_aRepeat.Stop();
 589     return true;
 590 }
 591
 592 IMPL_LINK_NOARG(ButtonPressRepeater, RepeatTimerHdl, Timer*, void)
 593 {
 594     m_aRepeat.SetTimeout(Application::GetSettings().GetMouseSettings().GetButtonRepeat());
 595     m_aLink.Call(m_rButton);
 596 }
 597
 598 weld::Window* GetPopupParent(vcl::Window& rOutWin, tools::Rectangle& rRect)
 599 {
 600     rRect.SetPos(rOutWin.OutputToScreenPixel(rRect.TopLeft()));
 601     AbsoluteScreenPixelRectangle aRectAbs = FloatingWindow::ImplConvertToAbsPos(&rOutWin, rRect);
 602
 603     vcl::Window* pWin = rOutWin.GetFrameWindow();
 604     // resolve from a possible BorderWindow to the ClientWindow (returns itself if not)
 605     pWin = pWin->ImplGetWindow();
 606
 607     rRect = FloatingWindow::ImplConvertToRelPos(pWin, aRectAbs);
 608     rRect.SetPos(pWin->ScreenToOutputPixel(rRect.TopLeft()));
 609
 610     return rOutWin.GetFrameWeld();
 611 }
 612
 613 void SetPointFont(OutputDevice& rDevice, const vcl::Font& rFont, bool bUseDeviceDPI)
 614 {
 615     auto pDefaultDevice = Application::GetDefaultDevice();
 616     if (pDefaultDevice)
 617         if (vcl::Window* pDefaultWindow = pDefaultDevice->GetOwnerWindow())
 618             pDefaultWindow->SetPointFont(rDevice, rFont, bUseDeviceDPI);
 619 }
 620
 621 ReorderingDropTarget::ReorderingDropTarget(weld::TreeView& rTreeView)
 622     : DropTargetHelper(rTreeView.get_drop_target())
 623     , m_rTreeView(rTreeView)
 624 {
 625 }
 626
 627 sal_Int8 ReorderingDropTarget::AcceptDrop(const AcceptDropEvent& rEvt)
 628 {
 629     // to enable the autoscroll when we're close to the edges
 630     m_rTreeView.get_dest_row_at_pos(rEvt.maPosPixel, nullptr, true);
 631     return DND_ACTION_MOVE;
 632 }
 633
 634 sal_Int8 ReorderingDropTarget::ExecuteDrop(const ExecuteDropEvent& rEvt)
 635 {
 636     weld::TreeView* pSource = m_rTreeView.get_drag_source();
 637     // only dragging within the same widget allowed
 638     if (!pSource || pSource != &m_rTreeView)
 639         return DND_ACTION_NONE;
 640
 641     std::unique_ptr<weld::TreeIter> xSource(m_rTreeView.make_iterator());
 642     if (!m_rTreeView.get_selected(xSource.get()))
 643         return DND_ACTION_NONE;
 644
 645     std::unique_ptr<weld::TreeIter> xTarget(m_rTreeView.make_iterator());
 646     int nTargetPos = -1;
 647     if (m_rTreeView.get_dest_row_at_pos(rEvt.maPosPixel, xTarget.get(), true))
 648         nTargetPos = m_rTreeView.get_iter_index_in_parent(*xTarget);
 649     m_rTreeView.move_subtree(*xSource, nullptr, nTargetPos);
 650
 651     return DND_ACTION_NONE;
 652 }
 653 }
 654
 655 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */