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/zforlist.hxx>
  14 #include <svl/zformat.hxx>
  15 #include <vcl/builderpage.hxx>
  16 #include <vcl/commandinfoprovider.hxx>
  17 #include <vcl/settings.hxx>
  18 #include <vcl/svapp.hxx>
  19 #include <vcl/weldutils.hxx>
  20
  21 BuilderPage::BuilderPage(weld::Widget* pParent, weld::DialogController* pController,
  22                          const OUString& rUIXMLDescription, const OString& rID, bool bIsMobile)
  23     : m_pDialogController(pController)
  24     , m_xBuilder(Application::CreateBuilder(pParent, rUIXMLDescription, bIsMobile))
  25     , m_xContainer(m_xBuilder->weld_container(rID))
  26 {
  27 }
  28
  29 void BuilderPage::Activate() {}
  30
  31 void BuilderPage::Deactivate() {}
  32
  33 BuilderPage::~BuilderPage() COVERITY_NOEXCEPT_FALSE {}
  34
  35 namespace weld
  36 {
  37 bool DialogController::runAsync(const std::shared_ptr<DialogController>& rController,
  38                                 const std::function<void(sal_Int32)>& func)
  39 {
  40     return rController->getDialog()->runAsync(rController, func);
  41 }
  42
  43 DialogController::~DialogController() COVERITY_NOEXCEPT_FALSE {}
  44
  45 Dialog* GenericDialogController::getDialog() { return m_xDialog.get(); }
  46
  47 GenericDialogController::GenericDialogController(weld::Widget* pParent, const OUString& rUIFile,
  48                                                  const OString& rDialogId, bool bMobile)
  49     : m_xBuilder(Application::CreateBuilder(pParent, rUIFile, bMobile))
  50     , m_xDialog(m_xBuilder->weld_dialog(rDialogId))
  51 {
  52 }
  53
  54 GenericDialogController::~GenericDialogController() COVERITY_NOEXCEPT_FALSE {}
  55
  56 Dialog* MessageDialogController::getDialog() { return m_xDialog.get(); }
  57
  58 MessageDialogController::MessageDialogController(weld::Widget* pParent, const OUString& rUIFile,
  59                                                  const OString& rDialogId,
  60                                                  const OString& rRelocateId)
  61     : m_xBuilder(Application::CreateBuilder(pParent, rUIFile))
  62     , m_xDialog(m_xBuilder->weld_message_dialog(rDialogId))
  63     , m_xContentArea(m_xDialog->weld_message_area())
  64 {
  65     if (!rRelocateId.isEmpty())
  66     {
  67         m_xRelocate = m_xBuilder->weld_container(rRelocateId);
  68         m_xOrigParent = m_xRelocate->weld_parent();
  69         //fdo#75121, a bit tricky because the widgets we want to align with
  70         //don't actually exist in the ui description, they're implied
  71         m_xOrigParent->move(m_xRelocate.get(), m_xContentArea.get());
  72     }
  73 }
  74
  75 MessageDialogController::~MessageDialogController()
  76 {
  77     if (m_xRelocate)
  78     {
  79         m_xContentArea->move(m_xRelocate.get(), m_xOrigParent.get());
  80     }
  81 }
  82
  83 AssistantController::AssistantController(weld::Widget* pParent, const OUString& rUIFile,
  84                                          const OString& rDialogId)
  85     : m_xBuilder(Application::CreateBuilder(pParent, rUIFile))
  86     , m_xAssistant(m_xBuilder->weld_assistant(rDialogId))
  87 {
  88 }
  89
  90 Dialog* AssistantController::getDialog() { return m_xAssistant.get(); }
  91
  92 AssistantController::~AssistantController() {}
  93
  94 void TriStateEnabled::ButtonToggled(weld::ToggleButton& rToggle)
  95 {
  96     if (bTriStateEnabled)
  97     {
  98         switch (eState)
  99         {
 100             case TRISTATE_INDET:
 101                 rToggle.set_state(TRISTATE_FALSE);
 102                 break;
 103             case TRISTATE_TRUE:
 104                 rToggle.set_state(TRISTATE_INDET);
 105                 break;
 106             case TRISTATE_FALSE:
 107                 rToggle.set_state(TRISTATE_TRUE);
 108                 break;
 109         }
 110     }
 111     eState = rToggle.get_state();
 112 }
 113
 114 void RemoveParentKeepChildren(weld::TreeView& rTreeView, weld::TreeIter& rParent)
 115 {
 116     if (rTreeView.iter_has_child(rParent))
 117     {
 118         std::unique_ptr<weld::TreeIter> xNewParent(rTreeView.make_iterator(&rParent));
 119         if (!rTreeView.iter_parent(*xNewParent))
 120             xNewParent.reset();
 121
 122         while (true)
 123         {
 124             std::unique_ptr<weld::TreeIter> xChild(rTreeView.make_iterator(&rParent));
 125             if (!rTreeView.iter_children(*xChild))
 126                 break;
 127             rTreeView.move_subtree(*xChild, xNewParent.get(), -1);
 128         }
 129     }
 130     rTreeView.remove(rParent);
 131 }
 132
 133 EntryFormatter::EntryFormatter(weld::FormattedSpinButton& rSpinButton)
 134     : m_rEntry(rSpinButton)
 135     , m_pSpinButton(&rSpinButton)
 136     , m_eOptions(Application::GetSettings().GetStyleSettings().GetSelectionOptions())
 137 {
 138     Init();
 139 }
 140
 141 EntryFormatter::EntryFormatter(weld::Entry& rEntry)
 142     : m_rEntry(rEntry)
 143     , m_pSpinButton(nullptr)
 144     , m_eOptions(Application::GetSettings().GetStyleSettings().GetSelectionOptions())
 145 {
 146     Init();
 147 }
 148
 149 EntryFormatter::~EntryFormatter()
 150 {
 151     m_rEntry.connect_changed(Link<weld::Entry&, void>());
 152     m_rEntry.connect_focus_out(Link<weld::Widget&, void>());
 153     if (m_pSpinButton)
 154         m_pSpinButton->SetFormatter(nullptr);
 155 }
 156
 157 void EntryFormatter::Init()
 158 {
 159     m_rEntry.connect_changed(LINK(this, EntryFormatter, ModifyHdl));
 160     m_rEntry.connect_focus_out(LINK(this, EntryFormatter, FocusOutHdl));
 161     if (m_pSpinButton)
 162         m_pSpinButton->SetFormatter(this);
 163 }
 164
 165 Selection EntryFormatter::GetEntrySelection() const
 166 {
 167     int nStartPos, nEndPos;
 168     m_rEntry.get_selection_bounds(nStartPos, nEndPos);
 169     return Selection(nStartPos, nEndPos);
 170 }
 171
 172 OUString EntryFormatter::GetEntryText() const { return m_rEntry.get_text(); }
 173
 174 void EntryFormatter::SetEntryText(const OUString& rText, const Selection& rSel)
 175 {
 176     m_rEntry.set_text(rText);
 177     auto nMin = rSel.Min();
 178     auto nMax = rSel.Max();
 179     m_rEntry.select_region(nMin < 0 ? 0 : nMin, nMax == SELECTION_MAX ? -1 : nMax);
 180 }
 181
 182 void EntryFormatter::SetEntryTextColor(const Color* pColor)
 183 {
 184     m_rEntry.set_font_color(pColor ? *pColor : COL_AUTO);
 185 }
 186
 187 void EntryFormatter::UpdateCurrentValue(double dCurrentValue)
 188 {
 189     Formatter::UpdateCurrentValue(dCurrentValue);
 190     if (m_pSpinButton)
 191         m_pSpinButton->sync_value_from_formatter();
 192 }
 193
 194 void EntryFormatter::ClearMinValue()
 195 {
 196     Formatter::ClearMinValue();
 197     if (m_pSpinButton)
 198         m_pSpinButton->sync_range_from_formatter();
 199 }
 200
 201 void EntryFormatter::SetMinValue(double dMin)
 202 {
 203     Formatter::SetMinValue(dMin);
 204     if (m_pSpinButton)
 205         m_pSpinButton->sync_range_from_formatter();
 206 }
 207
 208 void EntryFormatter::ClearMaxValue()
 209 {
 210     Formatter::ClearMaxValue();
 211     if (m_pSpinButton)
 212         m_pSpinButton->sync_range_from_formatter();
 213 }
 214
 215 void EntryFormatter::SetMaxValue(double dMin)
 216 {
 217     Formatter::SetMaxValue(dMin);
 218     if (m_pSpinButton)
 219         m_pSpinButton->sync_range_from_formatter();
 220 }
 221
 222 void EntryFormatter::SetSpinSize(double dStep)
 223 {
 224     Formatter::SetSpinSize(dStep);
 225     if (m_pSpinButton)
 226         m_pSpinButton->sync_increments_from_formatter();
 227 }
 228
 229 SelectionOptions EntryFormatter::GetEntrySelectionOptions() const { return m_eOptions; }
 230
 231 void EntryFormatter::FieldModified() { m_aModifyHdl.Call(m_rEntry); }
 232
 233 IMPL_LINK_NOARG(EntryFormatter, ModifyHdl, weld::Entry&, void)
 234 {
 235     // This leads to FieldModified getting called at the end of Modify() and
 236     // FieldModified then calls any modification callback
 237     Modify();
 238 }
 239
 240 IMPL_LINK_NOARG(EntryFormatter, FocusOutHdl, weld::Widget&, void)
 241 {
 242     EntryLostFocus();
 243     m_aFocusOutHdl.Call(m_rEntry);
 244 }
 245
 246 DoubleNumericFormatter::DoubleNumericFormatter(weld::Entry& rEntry)
 247     : EntryFormatter(rEntry)
 248 {
 249     ResetConformanceTester();
 250 }
 251
 252 DoubleNumericFormatter::DoubleNumericFormatter(weld::FormattedSpinButton& rSpinButton)
 253     : EntryFormatter(rSpinButton)
 254 {
 255     ResetConformanceTester();
 256 }
 257
 258 DoubleNumericFormatter::~DoubleNumericFormatter() = default;
 259
 260 void DoubleNumericFormatter::FormatChanged(FORMAT_CHANGE_TYPE nWhat)
 261 {
 262     ResetConformanceTester();
 263     EntryFormatter::FormatChanged(nWhat);
 264 }
 265
 266 bool DoubleNumericFormatter::CheckText(const OUString& sText) const
 267 {
 268     // We'd like to implement this using the NumberFormatter::IsNumberFormat, but unfortunately, this doesn't
 269     // recognize fragments of numbers (like, for instance "1e", which happens during entering e.g. "1e10")
 270     // Thus, the roundabout way via a regular expression
 271     return m_pNumberValidator->isValidNumericFragment(sText);
 272 }
 273
 274 void DoubleNumericFormatter::ResetConformanceTester()
 275 {
 276     // the thousands and the decimal separator are language dependent
 277     const SvNumberformat* pFormatEntry = GetOrCreateFormatter()->GetEntry(m_nFormatKey);
 278
 279     sal_Unicode cSeparatorThousand = ',';
 280     sal_Unicode cSeparatorDecimal = '.';
 281     if (pFormatEntry)
 282     {
 283         LocaleDataWrapper aLocaleInfo(LanguageTag(pFormatEntry->GetLanguage()));
 284
 285         OUString sSeparator = aLocaleInfo.getNumThousandSep();
 286         if (!sSeparator.isEmpty())
 287             cSeparatorThousand = sSeparator[0];
 288
 289         sSeparator = aLocaleInfo.getNumDecimalSep();
 290         if (!sSeparator.isEmpty())
 291             cSeparatorDecimal = sSeparator[0];
 292     }
 293
 294     m_pNumberValidator.reset(
 295         new validation::NumberValidator(cSeparatorThousand, cSeparatorDecimal));
 296 }
 297
 298 LongCurrencyFormatter::LongCurrencyFormatter(weld::Entry& rEntry)
 299     : EntryFormatter(rEntry)
 300     , m_bThousandSep(true)
 301 {
 302     Init();
 303 }
 304
 305 LongCurrencyFormatter::LongCurrencyFormatter(weld::FormattedSpinButton& rSpinButton)
 306     : EntryFormatter(rSpinButton)
 307     , m_bThousandSep(true)
 308 {
 309     Init();
 310 }
 311
 312 void LongCurrencyFormatter::Init()
 313 {
 314     SetOutputHdl(LINK(this, LongCurrencyFormatter, FormatOutputHdl));
 315     SetInputHdl(LINK(this, LongCurrencyFormatter, ParseInputHdl));
 316 }
 317
 318 void LongCurrencyFormatter::SetUseThousandSep(bool b)
 319 {
 320     m_bThousandSep = b;
 321     ReFormat();
 322 }
 323
 324 void LongCurrencyFormatter::SetCurrencySymbol(const OUString& rStr)
 325 {
 326     m_aCurrencySymbol = rStr;
 327     ReFormat();
 328 }
 329
 330 LongCurrencyFormatter::~LongCurrencyFormatter() = default;
 331
 332 TimeFormatter::TimeFormatter(weld::Entry& rEntry)
 333     : EntryFormatter(rEntry)
 334     , m_eFormat(TimeFieldFormat::F_NONE)
 335     , m_eTimeFormat(TimeFormat::Hour24)
 336     , m_bDuration(false)
 337 {
 338     Init();
 339 }
 340
 341 TimeFormatter::TimeFormatter(weld::FormattedSpinButton& rSpinButton)
 342     : EntryFormatter(rSpinButton)
 343     , m_eFormat(TimeFieldFormat::F_NONE)
 344     , m_eTimeFormat(TimeFormat::Hour24)
 345     , m_bDuration(false)
 346 {
 347     Init();
 348 }
 349
 350 void TimeFormatter::Init()
 351 {
 352     DisableRemainderFactor(); //so with hh::mm::ss, incrementing mm will not reset ss
 353
 354     SetOutputHdl(LINK(this, TimeFormatter, FormatOutputHdl));
 355     SetInputHdl(LINK(this, TimeFormatter, ParseInputHdl));
 356
 357     SetMin(tools::Time(0, 0));
 358     SetMax(tools::Time(23, 59, 59, 999999999));
 359
 360     // so the spin size can depend on which zone the cursor is in
 361     get_widget().connect_cursor_position(LINK(this, TimeFormatter, CursorChangedHdl));
 362     // and set the initial spin size
 363     CursorChangedHdl(get_widget());
 364 }
 365
 366 void TimeFormatter::SetExtFormat(ExtTimeFieldFormat eFormat)
 367 {
 368     switch (eFormat)
 369     {
 370         case ExtTimeFieldFormat::Short24H:
 371         {
 372             m_eTimeFormat = TimeFormat::Hour24;
 373             m_bDuration = false;
 374             m_eFormat = TimeFieldFormat::F_NONE;
 375         }
 376         break;
 377         case ExtTimeFieldFormat::Long24H:
 378         {
 379             m_eTimeFormat = TimeFormat::Hour24;
 380             m_bDuration = false;
 381             m_eFormat = TimeFieldFormat::F_SEC;
 382         }
 383         break;
 384         case ExtTimeFieldFormat::Short12H:
 385         {
 386             m_eTimeFormat = TimeFormat::Hour12;
 387             m_bDuration = false;
 388             m_eFormat = TimeFieldFormat::F_NONE;
 389         }
 390         break;
 391         case ExtTimeFieldFormat::Long12H:
 392         {
 393             m_eTimeFormat = TimeFormat::Hour12;
 394             m_bDuration = false;
 395             m_eFormat = TimeFieldFormat::F_SEC;
 396         }
 397         break;
 398         case ExtTimeFieldFormat::ShortDuration:
 399         {
 400             m_bDuration = true;
 401             m_eFormat = TimeFieldFormat::F_NONE;
 402         }
 403         break;
 404         case ExtTimeFieldFormat::LongDuration:
 405         {
 406             m_bDuration = true;
 407             m_eFormat = TimeFieldFormat::F_SEC;
 408         }
 409         break;
 410     }
 411
 412     ReFormat();
 413 }
 414
 415 void TimeFormatter::SetDuration(bool bDuration)
 416 {
 417     m_bDuration = bDuration;
 418     ReFormat();
 419 }
 420
 421 void TimeFormatter::SetTimeFormat(TimeFieldFormat eTimeFormat)
 422 {
 423     m_eFormat = eTimeFormat;
 424     ReFormat();
 425 }
 426
 427 TimeFormatter::~TimeFormatter() = default;
 428
 429 DateFormatter::DateFormatter(weld::Entry& rEntry)
 430     : EntryFormatter(rEntry)
 431     , m_eFormat(ExtDateFieldFormat::SystemShort)
 432 {
 433     Init();
 434 }
 435
 436 void DateFormatter::Init()
 437 {
 438     SetOutputHdl(LINK(this, DateFormatter, FormatOutputHdl));
 439     SetInputHdl(LINK(this, DateFormatter, ParseInputHdl));
 440
 441     SetMin(Date(1, 1, 1900));
 442     SetMax(Date(31, 12, 2200));
 443 }
 444
 445 void DateFormatter::SetExtDateFormat(ExtDateFieldFormat eFormat)
 446 {
 447     m_eFormat = eFormat;
 448     ReFormat();
 449 }
 450
 451 DateFormatter::~DateFormatter() = default;
 452
 453 PatternFormatter::PatternFormatter(weld::Entry& rEntry)
 454     : m_rEntry(rEntry)
 455     , m_bStrictFormat(false)
 456     , m_bSameMask(true)
 457     , m_bReformat(false)
 458     , m_bInPattKeyInput(false)
 459 {
 460     m_rEntry.connect_changed(LINK(this, PatternFormatter, ModifyHdl));
 461     m_rEntry.connect_focus_in(LINK(this, PatternFormatter, FocusInHdl));
 462     m_rEntry.connect_focus_out(LINK(this, PatternFormatter, FocusOutHdl));
 463     m_rEntry.connect_key_press(LINK(this, PatternFormatter, KeyInputHdl));
 464 }
 465
 466 IMPL_LINK_NOARG(PatternFormatter, ModifyHdl, weld::Entry&, void) { Modify(); }
 467
 468 IMPL_LINK_NOARG(PatternFormatter, FocusOutHdl, weld::Widget&, void)
 469 {
 470     EntryLostFocus();
 471     m_aFocusOutHdl.Call(m_rEntry);
 472 }
 473
 474 IMPL_LINK_NOARG(PatternFormatter, FocusInHdl, weld::Widget&, void)
 475 {
 476     EntryGainFocus();
 477     m_aFocusInHdl.Call(m_rEntry);
 478 }
 479
 480 PatternFormatter::~PatternFormatter()
 481 {
 482     m_rEntry.connect_changed(Link<weld::Entry&, void>());
 483     m_rEntry.connect_focus_out(Link<weld::Widget&, void>());
 484 }
 485
 486 int GetMinimumEditHeight()
 487 {
 488     // load this little .ui just to measure the height of an Entry
 489     std::unique_ptr<weld::Builder> xBuilder(
 490         Application::CreateBuilder(nullptr, "cui/ui/namedialog.ui"));
 491     std::unique_ptr<weld::Entry> xEntry(xBuilder->weld_entry("name_entry"));
 492     return xEntry->get_preferred_size().Height();
 493 }
 494
 495 WidgetStatusListener::WidgetStatusListener(weld::Widget* widget, const OUString& aCommand)
 496     : mWidget(widget)
 497 {
 498     css::uno::Reference<css::uno::XComponentContext> xContext
 499         = ::comphelper::getProcessComponentContext();
 500     css::uno::Reference<css::frame::XDesktop2> xDesktop = css::frame::Desktop::create(xContext);
 501
 502     css::uno::Reference<css::frame::XFrame> xFrame(xDesktop->getActiveFrame());
 503     if (!xFrame.is())
 504         xFrame = xDesktop;
 505
 506     mxFrame = xFrame;
 507
 508     maCommandURL.Complete = aCommand;
 509     css::uno::Reference<css::util::XURLTransformer> xParser
 510         = css::util::URLTransformer::create(xContext);
 511     xParser->parseStrict(maCommandURL);
 512 }
 513
 514 void WidgetStatusListener::startListening()
 515 {
 516     if (mxDispatch.is())
 517         mxDispatch->removeStatusListener(this, maCommandURL);
 518
 519     css::uno::Reference<css::frame::XDispatchProvider> xDispatchProvider(mxFrame,
 520                                                                          css::uno::UNO_QUERY);
 521     if (!xDispatchProvider.is())
 522         return;
 523
 524     mxDispatch = xDispatchProvider->queryDispatch(maCommandURL, "", 0);
 525     if (mxDispatch.is())
 526         mxDispatch->addStatusListener(this, maCommandURL);
 527 }
 528
 529 void WidgetStatusListener::statusChanged(const css::frame::FeatureStateEvent& rEvent)
 530 {
 531     mWidget->set_sensitive(rEvent.IsEnabled);
 532 }
 533
 534 void WidgetStatusListener::disposing(const css::lang::EventObject& /*Source*/)
 535 {
 536     mxDispatch.clear();
 537 }
 538
 539 void WidgetStatusListener::dispose()
 540 {
 541     if (mxDispatch.is())
 542     {
 543         mxDispatch->removeStatusListener(this, maCommandURL);
 544         mxDispatch.clear();
 545     }
 546     mxFrame.clear();
 547     mWidget = nullptr;
 548 }
 549 }
 550
 551 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */