?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bump product version to 7.6.3.2-android
[LibreOffice.git] / vcl / source / app / salvtables.cxx
blob5310e3279a11b80f397f852fe21e78cf9bbb87bb
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 <sal/config.h>
21
22 #include <limits>
23 #include <string_view>
24
25 #include <com/sun/star/accessibility/AccessibleRelationType.hpp>
26 #include <com/sun/star/awt/XWindow.hpp>
27 #include <com/sun/star/awt/XVclWindowPeer.hpp>
28 #include <o3tl/safeint.hxx>
29 #include <o3tl/sorted_vector.hxx>
30 #include <o3tl/string_view.hxx>
31 #include <officecfg/Office/Common.hxx>
32 #include <salframe.hxx>
33 #include <salinst.hxx>
34 #include <salvd.hxx>
35 #include <salprn.hxx>
36 #include <saltimer.hxx>
37 #include <salsession.hxx>
38 #include <salsys.hxx>
39 #include <salbmp.hxx>
40 #include <salobj.hxx>
41 #include <salmenu.hxx>
42 #include <strings.hrc>
43 #include <svdata.hxx>
44 #include <svimpbox.hxx>
45 #include <messagedialog.hxx>
46 #include <treeglue.hxx>
47 #include <unotools/accessiblerelationsethelper.hxx>
48 #include <unotools/configmgr.hxx>
49 #include <utility>
50 #include <tools/helpers.hxx>
51 #include <vcl/abstdlg.hxx>
52 #include <vcl/builder.hxx>
53 #include <vcl/toolkit/combobox.hxx>
54 #include <vcl/toolkit/dialog.hxx>
55 #include <vcl/toolkit/fixed.hxx>
56 #include <vcl/toolkit/fmtfield.hxx>
57 #include <vcl/headbar.hxx>
58 #include <vcl/toolkit/ivctrl.hxx>
59 #include <vcl/layout.hxx>
60 #include <vcl/toolkit/menubtn.hxx>
61 #include <vcl/toolkit/prgsbar.hxx>
62 #include <vcl/ptrstyle.hxx>
63 #include <slider.hxx>
64 #include <vcl/sysdata.hxx>
65 #include <vcl/toolkit/svlbitm.hxx>
66 #include <vcl/toolkit/svtabbx.hxx>
67 #include <vcl/tabctrl.hxx>
68 #include <vcl/tabpage.hxx>
69 #include <vcl/toolbox.hxx>
70 #include <vcl/toolkit/treelistentry.hxx>
71 #include <vcl/toolkit/throbber.hxx>
72 #include <vcl/toolkit/unowrap.hxx>
73 #include <vcl/weld.hxx>
74 #include <vcl/weldutils.hxx>
75 #include <vcl/toolkit/vclmedit.hxx>
76 #include <vcl/toolkit/viewdataentry.hxx>
77 #include <vcl/virdev.hxx>
78 #include <bitmaps.hlst>
79 #include <calendar.hxx>
80 #include <menutogglebutton.hxx>
81 #include <verticaltabctrl.hxx>
82 #include <window.h>
83 #include <wizdlg.hxx>
84 #include <salvtables.hxx>
85 #include <comphelper/lok.hxx>
86
87 SalFrame::SalFrame()
88 : m_pWindow(nullptr)
89 , m_pProc(nullptr)
90 {
91 }
92
93 // this file contains the virtual destructors of the sal interface
94 // compilers usually put their vtables where the destructor is
95
96 SalFrame::~SalFrame() {}
97
98 void SalFrame::SetCallback(vcl::Window* pWindow, SALFRAMEPROC pProc)
99 {
100 m_pWindow = pWindow;
101 m_pProc = pProc;
102 }
103
104 // default to full-frame flushes
105 // on ports where partial-flushes are much cheaper this method should be overridden
106 void SalFrame::Flush(const tools::Rectangle&) { Flush(); }
107
108 void SalFrame::SetRepresentedURL(const OUString&)
109 {
110 // currently this is Mac only functionality
111 }
112
113 OUString SalFrame::DumpSetPosSize(tools::Long nX, tools::Long nY, tools::Long nWidth,
114 tools::Long nHeight, sal_uInt16 nFlags)
115 {
116 // assuming the 4 integers normally don't have more than 4 digits, but might be negative
117 OUStringBuffer aBuffer(4 * 5 + 5);
118 if (nFlags & SAL_FRAME_POSSIZE_WIDTH)
119 aBuffer << nWidth << "x";
120 else
121 aBuffer << "?x";
122 if (nFlags & SAL_FRAME_POSSIZE_HEIGHT)
123 aBuffer << nHeight << "@(";
124 else
125 aBuffer << "?@(";
126 if (nFlags & SAL_FRAME_POSSIZE_X)
127 aBuffer << nX << ",";
128 else
129 aBuffer << "?,";
130 if (nFlags & SAL_FRAME_POSSIZE_Y)
131 aBuffer << nY << ")";
132 else
133 aBuffer << "?)";
134 return aBuffer.makeStringAndClear();
135 }
136
137 SalInstance::SalInstance(std::unique_ptr<comphelper::SolarMutex> pMutex)
138 : m_pYieldMutex(std::move(pMutex))
139 {
140 }
141
142 SalInstance::~SalInstance() {}
143
144 comphelper::SolarMutex* SalInstance::GetYieldMutex() { return m_pYieldMutex.get(); }
145
146 sal_uInt32 SalInstance::ReleaseYieldMutexAll() { return m_pYieldMutex->release(true); }
147
148 void SalInstance::AcquireYieldMutex(sal_uInt32 nCount) { m_pYieldMutex->acquire(nCount); }
149
150 std::unique_ptr<SalSession> SalInstance::CreateSalSession() { return nullptr; }
151
152 OpenGLContext* SalInstance::CreateOpenGLContext()
153 {
154 assert(!m_bSupportsOpenGL);
155 std::abort();
156 }
157
158 std::unique_ptr<SalMenu> SalInstance::CreateMenu(bool, Menu*)
159 {
160 // default: no native menus
161 return nullptr;
162 }
163
164 std::unique_ptr<SalMenuItem> SalInstance::CreateMenuItem(const SalItemParams&) { return nullptr; }
165
166 bool SalInstance::CallEventCallback(void const* pEvent, int nBytes)
167 {
168 return m_pEventInst.is() && m_pEventInst->dispatchEvent(pEvent, nBytes);
169 }
170
171 bool SalInstance::DoExecute(int&)
172 {
173 // can't run on system event loop without implementing DoExecute and DoQuit
174 if (Application::IsOnSystemEventLoop())
175 std::abort();
176 return false;
177 }
178
179 void SalInstance::DoQuit()
180 {
181 if (Application::IsOnSystemEventLoop())
182 std::abort();
183 }
184
185 SalTimer::~SalTimer() COVERITY_NOEXCEPT_FALSE {}
186
187 void SalBitmap::DropScaledCache()
188 {
189 if (ImplSVData* pSVData = ImplGetSVData())
190 {
191 auto& rCache = pSVData->maGDIData.maScaleCache;
192
193 rCache.remove_if([this](const lru_scale_cache::key_value_pair_t& rKeyValuePair) {
194 return rKeyValuePair.first.mpBitmap == this;
195 });
196 }
197 }
198
199 SalBitmap::~SalBitmap() { DropScaledCache(); }
200
201 SalSystem::~SalSystem() {}
202
203 SalPrinter::~SalPrinter() {}
204
205 bool SalPrinter::StartJob(const OUString*, const OUString&, const OUString&, ImplJobSetup*,
206 vcl::PrinterController&)
207 {
208 return false;
209 }
210
211 SalInfoPrinter::~SalInfoPrinter() {}
212
213 SalVirtualDevice::~SalVirtualDevice() {}
214
215 SalObject::~SalObject() {}
216
217 SalMenu::~SalMenu() {}
218
219 bool SalMenu::ShowNativePopupMenu(FloatingWindow*, const tools::Rectangle&, FloatWinPopupFlags)
220 {
221 return false;
222 }
223
224 void SalMenu::ShowCloseButton(bool) {}
225
226 bool SalMenu::AddMenuBarButton(const SalMenuButtonItem&) { return false; }
227
228 void SalMenu::RemoveMenuBarButton(sal_uInt16) {}
229
230 tools::Rectangle SalMenu::GetMenuBarButtonRectPixel(sal_uInt16, SalFrame*)
231 {
232 return tools::Rectangle();
233 }
234
235 int SalMenu::GetMenuBarHeight() const { return 0; }
236
237 void SalMenu::ApplyPersona() {}
238
239 SalMenuItem::~SalMenuItem() {}
240
241 class SalFlashAttention
242 {
243 private:
244 VclPtr<vcl::Window> m_xWidget;
245 Timer m_aFlashTimer;
246 Color m_aOrigControlBackground;
247 Wallpaper m_aOrigBackground;
248 bool m_bOrigControlBackground;
249 int m_nFlashCount;
250
251 void SetFlash()
252 {
253 Color aColor(Application::GetSettings().GetStyleSettings().GetHighlightColor());
254 m_xWidget->SetControlBackground(aColor);
255 }
256
257 void ClearFlash()
258 {
259 if (m_bOrigControlBackground)
260 m_xWidget->SetControlBackground(m_aOrigControlBackground);
261 else
262 m_xWidget->SetControlBackground();
263 }
264
265 void Flash()
266 {
267 constexpr int FlashesWanted = 1;
268
269 if (m_nFlashCount % 2 == 0)
270 ClearFlash();
271 else
272 SetFlash();
273
274 if (m_nFlashCount == FlashesWanted * 2)
275 return;
276
277 ++m_nFlashCount;
278
279 m_aFlashTimer.Start();
280 }
281
282 DECL_LINK(FlashTimeout, Timer*, void);
283
284 public:
285 SalFlashAttention(VclPtr<vcl::Window> xWidget)
286 : m_xWidget(std::move(xWidget))
287 , m_aFlashTimer("SalFlashAttention")
288 , m_bOrigControlBackground(false)
289 , m_nFlashCount(1)
290 {
291 m_aFlashTimer.SetTimeout(150);
292 m_aFlashTimer.SetInvokeHandler(LINK(this, SalFlashAttention, FlashTimeout));
293 }
294
295 void Start()
296 {
297 m_bOrigControlBackground = m_xWidget->IsControlBackground();
298 if (m_bOrigControlBackground)
299 m_aOrigControlBackground = m_xWidget->GetControlBackground();
300 m_aFlashTimer.Start();
301 }
302
303 ~SalFlashAttention() { ClearFlash(); }
304 };
305
306 IMPL_LINK_NOARG(SalFlashAttention, FlashTimeout, Timer*, void) { Flash(); }
307
308 void SalInstanceWidget::ensure_event_listener()
309 {
310 if (!m_bEventListener)
311 {
312 m_xWidget->AddEventListener(LINK(this, SalInstanceWidget, EventListener));
313 m_bEventListener = true;
314 }
315 }
316
317 // we want the ability to mark key events as handled, so use this variant
318 // for those, we get all keystrokes in this case, so we will need to filter
319 // them later
320 void SalInstanceWidget::ensure_key_listener()
321 {
322 if (!m_bKeyEventListener)
323 {
324 Application::AddKeyListener(LINK(this, SalInstanceWidget, KeyEventListener));
325 m_bKeyEventListener = true;
326 }
327 }
328
329 // we want the ability to know about mouse events that happen in our children
330 // so use this variant, we will need to filter them later
331 void SalInstanceWidget::ensure_mouse_listener()
332 {
333 if (!m_bMouseEventListener)
334 {
335 m_xWidget->AddChildEventListener(LINK(this, SalInstanceWidget, MouseEventListener));
336 m_bMouseEventListener = true;
337 }
338 }
339
340 void SalInstanceWidget::set_background(const Color& rColor)
341 {
342 m_xWidget->SetControlBackground(rColor);
343 m_xWidget->SetBackground(m_xWidget->GetControlBackground());
344 if (m_xWidget->GetStyle() & WB_CLIPCHILDREN)
345 {
346 // turn off WB_CLIPCHILDREN otherwise the bg won't extend "under"
347 // transparent children of the widget e.g. expander in sidebar panel header
348 m_xWidget->SetStyle(m_xWidget->GetStyle() & ~WB_CLIPCHILDREN);
349 // and toggle mbClipChildren on instead otherwise the bg won't fill e.g.
350 // deck titlebar header when its width is stretched
351 WindowImpl* pImpl = m_xWidget->ImplGetWindowImpl();
352 pImpl->mbClipChildren = true;
353 }
354 }
355
356 SalInstanceWidget::SalInstanceWidget(vcl::Window* pWidget, SalInstanceBuilder* pBuilder,
357 bool bTakeOwnership)
358 : m_xWidget(pWidget)
359 , m_pBuilder(pBuilder)
360 , m_bTakeOwnership(bTakeOwnership)
361 , m_bEventListener(false)
362 , m_bKeyEventListener(false)
363 , m_bMouseEventListener(false)
364 , m_nBlockNotify(0)
365 , m_nFreezeCount(0)
366 {
367 }
368
369 void SalInstanceWidget::set_sensitive(bool sensitive) { m_xWidget->Enable(sensitive); }
370
371 bool SalInstanceWidget::get_sensitive() const { return m_xWidget->IsEnabled(); }
372
373 bool SalInstanceWidget::get_visible() const { return m_xWidget->IsVisible(); }
374
375 bool SalInstanceWidget::is_visible() const { return m_xWidget->IsReallyVisible(); }
376
377 void SalInstanceWidget::set_can_focus(bool bCanFocus)
378 {
379 auto nStyle = m_xWidget->GetStyle() & ~(WB_TABSTOP | WB_NOTABSTOP);
380 if (bCanFocus)
381 nStyle |= WB_TABSTOP;
382 else
383 nStyle |= WB_NOTABSTOP;
384 m_xWidget->SetStyle(nStyle);
385 }
386
387 void SalInstanceWidget::grab_focus()
388 {
389 if (has_focus())
390 return;
391 m_xWidget->GrabFocus();
392 }
393
394 bool SalInstanceWidget::has_focus() const { return m_xWidget->HasFocus(); }
395
396 bool SalInstanceWidget::is_active() const { return m_xWidget->IsActive(); }
397
398 bool SalInstanceWidget::has_child_focus() const { return m_xWidget->HasChildPathFocus(true); }
399
400 void SalInstanceWidget::show() { m_xWidget->Show(); }
401
402 void SalInstanceWidget::hide() { m_xWidget->Hide(); }
403
404 void SalInstanceWidget::set_size_request(int nWidth, int nHeight)
405 {
406 m_xWidget->set_width_request(nWidth);
407 m_xWidget->set_height_request(nHeight);
408 }
409
410 Size SalInstanceWidget::get_size_request() const
411 {
412 return Size(m_xWidget->get_width_request(), m_xWidget->get_height_request());
413 }
414
415 Size SalInstanceWidget::get_preferred_size() const { return m_xWidget->get_preferred_size(); }
416
417 float SalInstanceWidget::get_approximate_digit_width() const
418 {
419 return m_xWidget->approximate_digit_width();
420 }
421
422 int SalInstanceWidget::get_text_height() const { return m_xWidget->GetTextHeight(); }
423
424 Size SalInstanceWidget::get_pixel_size(const OUString& rText) const
425 {
426 //TODO, or do I want GetTextBoundRect ?, just using width at the moment anyway
427 return Size(m_xWidget->GetTextWidth(rText), m_xWidget->GetTextHeight());
428 }
429
430 vcl::Font SalInstanceWidget::get_font() { return m_xWidget->GetPointFont(*m_xWidget->GetOutDev()); }
431
432 OUString SalInstanceWidget::get_buildable_name() const { return m_xWidget->get_id(); }
433
434 void SalInstanceWidget::set_buildable_name(const OUString& rId) { return m_xWidget->set_id(rId); }
435
436 void SalInstanceWidget::set_help_id(const OUString& rId) { return m_xWidget->SetHelpId(rId); }
437
438 OUString SalInstanceWidget::get_help_id() const { return m_xWidget->GetHelpId(); }
439
440 void SalInstanceWidget::set_grid_left_attach(int nAttach)
441 {
442 m_xWidget->set_grid_left_attach(nAttach);
443 }
444
445 int SalInstanceWidget::get_grid_left_attach() const { return m_xWidget->get_grid_left_attach(); }
446
447 void SalInstanceWidget::set_grid_width(int nCols) { m_xWidget->set_grid_width(nCols); }
448
449 void SalInstanceWidget::set_grid_top_attach(int nAttach)
450 {
451 m_xWidget->set_grid_top_attach(nAttach);
452 }
453
454 int SalInstanceWidget::get_grid_top_attach() const { return m_xWidget->get_grid_top_attach(); }
455
456 void SalInstanceWidget::set_hexpand(bool bExpand) { m_xWidget->set_hexpand(bExpand); }
457
458 bool SalInstanceWidget::get_hexpand() const { return m_xWidget->get_hexpand(); }
459
460 void SalInstanceWidget::set_vexpand(bool bExpand) { m_xWidget->set_vexpand(bExpand); }
461
462 bool SalInstanceWidget::get_vexpand() const { return m_xWidget->get_vexpand(); }
463
464 void SalInstanceWidget::set_margin_top(int nMargin) { m_xWidget->set_margin_top(nMargin); }
465
466 void SalInstanceWidget::set_margin_bottom(int nMargin) { m_xWidget->set_margin_bottom(nMargin); }
467
468 void SalInstanceWidget::set_margin_start(int nMargin) { m_xWidget->set_margin_start(nMargin); }
469
470 void SalInstanceWidget::set_margin_end(int nMargin) { m_xWidget->set_margin_end(nMargin); }
471
472 int SalInstanceWidget::get_margin_top() const { return m_xWidget->get_margin_top(); }
473
474 int SalInstanceWidget::get_margin_bottom() const { return m_xWidget->get_margin_bottom(); }
475
476 int SalInstanceWidget::get_margin_start() const { return m_xWidget->get_margin_start(); }
477
478 int SalInstanceWidget::get_margin_end() const { return m_xWidget->get_margin_end(); }
479
480 void SalInstanceWidget::set_accessible_name(const OUString& rName)
481 {
482 m_xWidget->SetAccessibleName(rName);
483 }
484
485 void SalInstanceWidget::set_accessible_description(const OUString& rDescription)
486 {
487 m_xWidget->SetAccessibleDescription(rDescription);
488 }
489
490 OUString SalInstanceWidget::get_accessible_name() const { return m_xWidget->GetAccessibleName(); }
491
492 OUString SalInstanceWidget::get_accessible_description() const
493 {
494 return m_xWidget->GetAccessibleDescription();
495 }
496
497 void SalInstanceWidget::set_accessible_relation_labeled_by(weld::Widget* pLabel)
498 {
499 if (vcl::Window* pOldLabel = m_xWidget->GetAccessibleRelationLabeledBy())
500 pOldLabel->SetAccessibleRelationLabelFor(nullptr);
501 vcl::Window* pA11yLabel
502 = pLabel ? dynamic_cast<SalInstanceWidget&>(*pLabel).getWidget() : nullptr;
503 m_xWidget->SetAccessibleRelationLabeledBy(pA11yLabel);
504 if (pA11yLabel)
505 pA11yLabel->SetAccessibleRelationLabelFor(m_xWidget);
506 }
507
508 void SalInstanceWidget::set_tooltip_text(const OUString& rTip)
509 {
510 m_xWidget->SetQuickHelpText(rTip);
511 }
512
513 OUString SalInstanceWidget::get_tooltip_text() const { return m_xWidget->GetQuickHelpText(); }
514
515 void SalInstanceWidget::set_cursor_data(void* pData)
516 {
517 vcl::Cursor* pCursor = static_cast<vcl::Cursor*>(pData);
518 if (!pCursor)
519 return;
520
521 m_xWidget->SetCursor(pCursor);
522 }
523
524 void SalInstanceWidget::connect_focus_in(const Link<Widget&, void>& rLink)
525 {
526 ensure_event_listener();
527 weld::Widget::connect_focus_in(rLink);
528 }
529
530 void SalInstanceWidget::connect_mnemonic_activate(const Link<Widget&, bool>& rLink)
531 {
532 m_xWidget->SetMnemonicActivateHdl(LINK(this, SalInstanceWidget, MnemonicActivateHdl));
533 weld::Widget::connect_mnemonic_activate(rLink);
534 }
535
536 void SalInstanceWidget::connect_focus_out(const Link<Widget&, void>& rLink)
537 {
538 ensure_event_listener();
539 weld::Widget::connect_focus_out(rLink);
540 }
541
542 void SalInstanceWidget::connect_size_allocate(const Link<const Size&, void>& rLink)
543 {
544 ensure_event_listener();
545 weld::Widget::connect_size_allocate(rLink);
546 }
547
548 void SalInstanceWidget::connect_mouse_press(const Link<const MouseEvent&, bool>& rLink)
549 {
550 ensure_mouse_listener();
551 weld::Widget::connect_mouse_press(rLink);
552 }
553
554 void SalInstanceWidget::connect_mouse_move(const Link<const MouseEvent&, bool>& rLink)
555 {
556 ensure_mouse_listener();
557 weld::Widget::connect_mouse_move(rLink);
558 }
559
560 void SalInstanceWidget::connect_mouse_release(const Link<const MouseEvent&, bool>& rLink)
561 {
562 ensure_mouse_listener();
563 weld::Widget::connect_mouse_release(rLink);
564 }
565
566 void SalInstanceWidget::connect_key_press(const Link<const KeyEvent&, bool>& rLink)
567 {
568 ensure_key_listener();
569 weld::Widget::connect_key_press(rLink);
570 }
571
572 void SalInstanceWidget::connect_key_release(const Link<const KeyEvent&, bool>& rLink)
573 {
574 ensure_key_listener();
575 weld::Widget::connect_key_release(rLink);
576 }
577
578 IMPL_LINK(SalInstanceWidget, SettingsChangedHdl, VclWindowEvent&, rEvent, void)
579 {
580 if (rEvent.GetId() != VclEventId::WindowDataChanged)
581 return;
582
583 DataChangedEvent* pData = static_cast<DataChangedEvent*>(rEvent.GetData());
584 if (pData->GetType() == DataChangedEventType::SETTINGS)
585 m_aStyleUpdatedHdl.Call(*this);
586 }
587
588 void SalInstanceWidget::connect_style_updated(const Link<Widget&, void>& rLink)
589 {
590 if (m_aStyleUpdatedHdl.IsSet())
591 m_xWidget->RemoveEventListener(LINK(this, SalInstanceWidget, SettingsChangedHdl));
592 weld::Widget::connect_style_updated(rLink);
593 if (m_aStyleUpdatedHdl.IsSet())
594 m_xWidget->AddEventListener(LINK(this, SalInstanceWidget, SettingsChangedHdl));
595 }
596
597 bool SalInstanceWidget::get_extents_relative_to(const Widget& rRelative, int& x, int& y, int& width,
598 int& height) const
599 {
600 tools::Rectangle aRect(m_xWidget->GetWindowExtentsRelative(
601 dynamic_cast<const SalInstanceWidget&>(rRelative).getWidget()));
602 x = aRect.Left();
603 y = aRect.Top();
604 width = aRect.GetWidth();
605 height = aRect.GetHeight();
606 return true;
607 }
608
609 void SalInstanceWidget::grab_add() { m_xWidget->CaptureMouse(); }
610
611 bool SalInstanceWidget::has_grab() const { return m_xWidget->IsMouseCaptured(); }
612
613 void SalInstanceWidget::grab_remove() { m_xWidget->ReleaseMouse(); }
614
615 bool SalInstanceWidget::get_direction() const { return m_xWidget->IsRTLEnabled(); }
616
617 void SalInstanceWidget::set_direction(bool bRTL) { m_xWidget->EnableRTL(bRTL); }
618
619 void SalInstanceWidget::freeze()
620 {
621 if (m_nFreezeCount == 0)
622 m_xWidget->SetUpdateMode(false);
623 ++m_nFreezeCount;
624 }
625
626 void SalInstanceWidget::thaw()
627 {
628 --m_nFreezeCount;
629 if (m_nFreezeCount == 0)
630 m_xWidget->SetUpdateMode(true);
631 }
632
633 void SalInstanceWidget::set_busy_cursor(bool bBusy)
634 {
635 if (!m_xWidget)
636 {
637 return;
638 }
639
640 if (bBusy)
641 m_xWidget->EnterWait();
642 else
643 m_xWidget->LeaveWait();
644 }
645
646 void SalInstanceWidget::queue_resize() { m_xWidget->queue_resize(); }
647
648 SalInstanceWidget::~SalInstanceWidget()
649 {
650 if (m_aStyleUpdatedHdl.IsSet())
651 m_xWidget->RemoveEventListener(LINK(this, SalInstanceWidget, SettingsChangedHdl));
652 if (m_aMnemonicActivateHdl.IsSet())
653 m_xWidget->SetMnemonicActivateHdl(Link<vcl::Window&, bool>());
654 if (m_bMouseEventListener)
655 m_xWidget->RemoveChildEventListener(LINK(this, SalInstanceWidget, MouseEventListener));
656 if (m_bKeyEventListener)
657 Application::RemoveKeyListener(LINK(this, SalInstanceWidget, KeyEventListener));
658 if (m_bEventListener)
659 m_xWidget->RemoveEventListener(LINK(this, SalInstanceWidget, EventListener));
660 if (m_bTakeOwnership)
661 m_xWidget.disposeAndClear();
662 }
663
664 vcl::Window* SalInstanceWidget::getWidget() const { return m_xWidget; }
665
666 void SalInstanceWidget::disable_notify_events() { ++m_nBlockNotify; }
667
668 bool SalInstanceWidget::notify_events_disabled() const { return m_nBlockNotify != 0; }
669
670 void SalInstanceWidget::enable_notify_events() { --m_nBlockNotify; }
671
672 OUString SalInstanceWidget::strip_mnemonic(const OUString& rLabel) const
673 {
674 return rLabel.replaceFirst("~", "");
675 }
676
677 VclPtr<VirtualDevice> SalInstanceWidget::create_virtual_device() const
678 {
679 // create with (annoying) separate alpha layer that LibreOffice itself uses
680 return VclPtr<VirtualDevice>::Create(*Application::GetDefaultDevice(),
681 DeviceFormat::WITH_ALPHA);
682 }
683
684 void SalInstanceWidget::call_attention_to()
685 {
686 m_xFlashAttention.reset(new SalFlashAttention(m_xWidget));
687 m_xFlashAttention->Start();
688 }
689
690 css::uno::Reference<css::datatransfer::dnd::XDropTarget> SalInstanceWidget::get_drop_target()
691 {
692 return m_xWidget->GetDropTarget();
693 }
694
695 css::uno::Reference<css::datatransfer::clipboard::XClipboard>
696 SalInstanceWidget::get_clipboard() const
697 {
698 return m_xWidget->GetClipboard();
699 }
700
701 void SalInstanceWidget::connect_get_property_tree(const Link<tools::JsonWriter&, void>& rLink)
702 {
703 m_xWidget->SetDumpAsPropertyTreeHdl(rLink);
704 }
705
706 void SalInstanceWidget::get_property_tree(tools::JsonWriter& rJsonWriter)
707 {
708 m_xWidget->DumpAsPropertyTree(rJsonWriter);
709 }
710
711 void SalInstanceWidget::set_stack_background()
712 {
713 set_background(m_xWidget->GetSettings().GetStyleSettings().GetWindowColor());
714 }
715
716 void SalInstanceWidget::set_title_background()
717 {
718 set_background(m_xWidget->GetSettings().GetStyleSettings().GetShadowColor());
719 }
720
721 void SalInstanceWidget::set_toolbar_background()
722 {
723 m_xWidget->SetBackground();
724 m_xWidget->SetPaintTransparent(true);
725 }
726
727 void SalInstanceWidget::set_highlight_background()
728 {
729 set_background(m_xWidget->GetSettings().GetStyleSettings().GetHighlightColor());
730 }
731
732 SystemWindow* SalInstanceWidget::getSystemWindow() { return m_xWidget->GetSystemWindow(); }
733
734 void SalInstanceWidget::HandleEventListener(VclWindowEvent& rEvent)
735 {
736 if (rEvent.GetId() == VclEventId::WindowGetFocus)
737 m_aFocusInHdl.Call(*this);
738 else if (rEvent.GetId() == VclEventId::WindowLoseFocus)
739 m_aFocusOutHdl.Call(*this);
740 else if (rEvent.GetId() == VclEventId::WindowResize)
741 m_aSizeAllocateHdl.Call(m_xWidget->GetSizePixel());
742 }
743
744 namespace
745 {
746 MouseEvent TransformEvent(const MouseEvent& rEvent, const vcl::Window* pParent,
747 const vcl::Window* pChild)
748 {
749 return MouseEvent(
750 pParent->ScreenToOutputPixel(pChild->OutputToScreenPixel(rEvent.GetPosPixel())),
751 rEvent.GetClicks(), rEvent.GetMode(), rEvent.GetButtons(), rEvent.GetModifier());
752 }
753 }
754
755 void SalInstanceWidget::HandleMouseEventListener(VclWindowEvent& rWinEvent)
756 {
757 if (rWinEvent.GetId() == VclEventId::WindowMouseButtonDown)
758 {
759 if (m_xWidget == rWinEvent.GetWindow())
760 {
761 const MouseEvent* pMouseEvent = static_cast<const MouseEvent*>(rWinEvent.GetData());
762 m_aMousePressHdl.Call(*pMouseEvent);
763 }
764 else if (m_xWidget->ImplIsChild(rWinEvent.GetWindow()))
765 {
766 const MouseEvent* pMouseEvent = static_cast<const MouseEvent*>(rWinEvent.GetData());
767 const MouseEvent aTransformedEvent(
768 TransformEvent(*pMouseEvent, m_xWidget, rWinEvent.GetWindow()));
769 m_aMousePressHdl.Call(aTransformedEvent);
770 }
771 }
772 else if (rWinEvent.GetId() == VclEventId::WindowMouseButtonUp)
773 {
774 if (m_xWidget == rWinEvent.GetWindow())
775 {
776 const MouseEvent* pMouseEvent = static_cast<const MouseEvent*>(rWinEvent.GetData());
777 m_aMouseReleaseHdl.Call(*pMouseEvent);
778 }
779 else if (m_xWidget->ImplIsChild(rWinEvent.GetWindow()))
780 {
781 const MouseEvent* pMouseEvent = static_cast<const MouseEvent*>(rWinEvent.GetData());
782 const MouseEvent aTransformedEvent(
783 TransformEvent(*pMouseEvent, m_xWidget, rWinEvent.GetWindow()));
784 m_aMouseReleaseHdl.Call(aTransformedEvent);
785 }
786 }
787 else if (rWinEvent.GetId() == VclEventId::WindowMouseMove)
788 {
789 if (m_xWidget == rWinEvent.GetWindow())
790 {
791 const MouseEvent* pMouseEvent = static_cast<const MouseEvent*>(rWinEvent.GetData());
792 m_aMouseMotionHdl.Call(*pMouseEvent);
793 }
794 else if (m_xWidget->ImplIsChild(rWinEvent.GetWindow()))
795 {
796 const MouseEvent* pMouseEvent = static_cast<const MouseEvent*>(rWinEvent.GetData());
797 const MouseEvent aTransformedEvent(
798 TransformEvent(*pMouseEvent, m_xWidget, rWinEvent.GetWindow()));
799 m_aMouseMotionHdl.Call(aTransformedEvent);
800 }
801 }
802 }
803
804 bool SalInstanceWidget::HandleKeyEventListener(VclWindowEvent& rEvent)
805 {
806 // we get all key events here, ignore them unless we have focus
807 if (!m_xWidget->HasChildPathFocus())
808 return false;
809 if (rEvent.GetId() == VclEventId::WindowKeyInput)
810 {
811 const KeyEvent* pKeyEvent = static_cast<const KeyEvent*>(rEvent.GetData());
812 return m_aKeyPressHdl.Call(*pKeyEvent);
813 }
814 else if (rEvent.GetId() == VclEventId::WindowKeyUp)
815 {
816 const KeyEvent* pKeyEvent = static_cast<const KeyEvent*>(rEvent.GetData());
817 return m_aKeyReleaseHdl.Call(*pKeyEvent);
818 }
819 return false;
820 }
821
822 IMPL_LINK(SalInstanceWidget, EventListener, VclWindowEvent&, rEvent, void)
823 {
824 HandleEventListener(rEvent);
825 }
826
827 IMPL_LINK(SalInstanceWidget, KeyEventListener, VclWindowEvent&, rEvent, bool)
828 {
829 return HandleKeyEventListener(rEvent);
830 }
831
832 IMPL_LINK(SalInstanceWidget, MouseEventListener, VclWindowEvent&, rEvent, void)
833 {
834 HandleMouseEventListener(rEvent);
835 }
836
837 IMPL_LINK_NOARG(SalInstanceWidget, MnemonicActivateHdl, vcl::Window&, bool)
838 {
839 return m_aMnemonicActivateHdl.Call(*this);
840 }
841
842 namespace
843 {
844 Image createImage(const OUString& rImage)
845 {
846 if (rImage.isEmpty())
847 return Image();
848 if (rImage.lastIndexOf('.') != rImage.getLength() - 4)
849 {
850 assert((rImage == "dialog-warning" || rImage == "dialog-error"
851 || rImage == "dialog-information")
852 && "unknown stock image");
853 if (rImage == "dialog-warning")
854 return Image(StockImage::Yes, IMG_WARN);
855 else if (rImage == "dialog-error")
856 return Image(StockImage::Yes, IMG_ERROR);
857 else if (rImage == "dialog-information")
858 return Image(StockImage::Yes, IMG_INFO);
859 }
860 return Image(StockImage::Yes, rImage);
861 }
862
863 Image createImage(const VirtualDevice& rDevice)
864 {
865 return Image(rDevice.GetBitmapEx(Point(), rDevice.GetOutputSizePixel()));
866 }
867
868 sal_uInt16 insert_to_menu(sal_uInt16 nLastId, PopupMenu* pMenu, int pos, const OUString& rId,
869 const OUString& rStr, const OUString* pIconName,
870 const VirtualDevice* pImageSurface,
871 const css::uno::Reference<css::graphic::XGraphic>& rImage,
872 TriState eCheckRadioFalse)
873 {
874 const sal_uInt16 nNewid = nLastId + 1;
875
876 MenuItemBits nBits;
877 if (eCheckRadioFalse == TRISTATE_TRUE)
878 nBits = MenuItemBits::CHECKABLE;
879 else if (eCheckRadioFalse == TRISTATE_FALSE)
880 nBits = MenuItemBits::CHECKABLE | MenuItemBits::RADIOCHECK;
881 else
882 nBits = MenuItemBits::NONE;
883
884 pMenu->InsertItem(nNewid, rStr, nBits, rId, pos == -1 ? MENU_APPEND : pos);
885 if (pIconName)
886 {
887 pMenu->SetItemImage(nNewid, createImage(*pIconName));
888 }
889 else if (pImageSurface)
890 {
891 pMenu->SetItemImage(nNewid, createImage(*pImageSurface));
892 }
893 else if (rImage)
894 {
895 pMenu->SetItemImage(nNewid, Image(rImage));
896 }
897 return nNewid;
898 }
899 }
900
901 SalInstanceMenu::SalInstanceMenu(PopupMenu* pMenu, bool bTakeOwnership)
902 : m_xMenu(pMenu)
903 , m_bTakeOwnership(bTakeOwnership)
904 {
905 const auto nCount = m_xMenu->GetItemCount();
906 m_nLastId = nCount ? pMenu->GetItemId(nCount - 1) : 0;
907 m_xMenu->SetSelectHdl(LINK(this, SalInstanceMenu, SelectMenuHdl));
908 }
909 OUString SalInstanceMenu::popup_at_rect(weld::Widget* pParent, const tools::Rectangle& rRect,
910 weld::Placement ePlace)
911 {
912 SalInstanceWidget* pVclWidget = dynamic_cast<SalInstanceWidget*>(pParent);
913 assert(pVclWidget);
914 PopupMenuFlags eFlags = PopupMenuFlags::NoMouseUpClose;
915 if (ePlace == weld::Placement::Under)
916 eFlags = eFlags | PopupMenuFlags::ExecuteDown;
917 else
918 eFlags = eFlags | PopupMenuFlags::ExecuteRight;
919 m_xMenu->Execute(pVclWidget->getWidget(), rRect, eFlags);
920 return m_xMenu->GetCurItemIdent();
921 }
922 void SalInstanceMenu::set_sensitive(const OUString& rIdent, bool bSensitive)
923 {
924 m_xMenu->EnableItem(rIdent, bSensitive);
925 }
926 bool SalInstanceMenu::get_sensitive(const OUString& rIdent) const
927 {
928 return m_xMenu->IsItemEnabled(m_xMenu->GetItemId(rIdent));
929 }
930 void SalInstanceMenu::set_active(const OUString& rIdent, bool bActive)
931 {
932 m_xMenu->CheckItem(rIdent, bActive);
933 }
934 bool SalInstanceMenu::get_active(const OUString& rIdent) const
935 {
936 return m_xMenu->IsItemChecked(m_xMenu->GetItemId(rIdent));
937 }
938 void SalInstanceMenu::set_label(const OUString& rIdent, const OUString& rLabel)
939 {
940 m_xMenu->SetItemText(m_xMenu->GetItemId(rIdent), rLabel);
941 }
942 OUString SalInstanceMenu::get_label(const OUString& rIdent) const
943 {
944 return m_xMenu->GetItemText(m_xMenu->GetItemId(rIdent));
945 }
946 void SalInstanceMenu::set_visible(const OUString& rIdent, bool bShow)
947 {
948 m_xMenu->ShowItem(m_xMenu->GetItemId(rIdent), bShow);
949 }
950 void SalInstanceMenu::clear() { m_xMenu->Clear(); }
951 void SalInstanceMenu::insert(int pos, const OUString& rId, const OUString& rStr,
952 const OUString* pIconName, VirtualDevice* pImageSurface,
953 const css::uno::Reference<css::graphic::XGraphic>& rImage,
954 TriState eCheckRadioFalse)
955 {
956 m_nLastId = insert_to_menu(m_nLastId, m_xMenu, pos, rId, rStr, pIconName, pImageSurface, rImage,
957 eCheckRadioFalse);
958 }
959 void SalInstanceMenu::insert_separator(int pos, const OUString& rId)
960 {
961 auto nInsertPos = pos == -1 ? MENU_APPEND : pos;
962 m_xMenu->InsertSeparator(rId, nInsertPos);
963 }
964 void SalInstanceMenu::remove(const OUString& rId)
965 {
966 m_xMenu->RemoveItem(m_xMenu->GetItemPos(m_xMenu->GetItemId(rId)));
967 }
968 int SalInstanceMenu::n_children() const { return m_xMenu->GetItemCount(); }
969 OUString SalInstanceMenu::get_id(int pos) const
970 {
971 return m_xMenu->GetItemIdent(m_xMenu->GetItemId(pos));
972 }
973 PopupMenu* SalInstanceMenu::getMenu() const { return m_xMenu.get(); }
974 SalInstanceMenu::~SalInstanceMenu()
975 {
976 m_xMenu->SetSelectHdl(Link<::Menu*, bool>());
977 if (m_bTakeOwnership)
978 m_xMenu.disposeAndClear();
979 }
980
981 IMPL_LINK_NOARG(SalInstanceMenu, SelectMenuHdl, ::Menu*, bool)
982 {
983 signal_activate(m_xMenu->GetCurItemIdent());
984 /* tdf#131333 Menu::Select depends on a false here to allow
985 propagating a submens's selected id to its parent menu to become its
986 selected id.
987
988 without this, while gen menus already have propagated this to its parent
989 in MenuFloatingWindow::EndExecute, SalMenus as used under kf5/macOS
990 won't propagate the selected id
991 */
992 return false;
993 }
994
995 SalInstanceToolbar::SalInstanceToolbar(ToolBox* pToolBox, SalInstanceBuilder* pBuilder,
996 bool bTakeOwnership)
997 : SalInstanceWidget(pToolBox, pBuilder, bTakeOwnership)
998 , m_xToolBox(pToolBox)
999 {
1000 m_xToolBox->SetSelectHdl(LINK(this, SalInstanceToolbar, ClickHdl));
1001 m_xToolBox->SetDropdownClickHdl(LINK(this, SalInstanceToolbar, DropdownClick));
1002 }
1003
1004 void SalInstanceToolbar::set_item_sensitive(const OUString& rIdent, bool bSensitive)
1005 {
1006 m_xToolBox->EnableItem(m_xToolBox->GetItemId(rIdent), bSensitive);
1007 }
1008
1009 bool SalInstanceToolbar::get_item_sensitive(const OUString& rIdent) const
1010 {
1011 return m_xToolBox->IsItemEnabled(m_xToolBox->GetItemId(rIdent));
1012 }
1013
1014 void SalInstanceToolbar::set_item_visible(const OUString& rIdent, bool bVisible)
1015 {
1016 m_xToolBox->ShowItem(m_xToolBox->GetItemId(rIdent), bVisible);
1017 }
1018
1019 void SalInstanceToolbar::set_item_help_id(const OUString& rIdent, const OUString& rHelpId)
1020 {
1021 m_xToolBox->SetHelpId(m_xToolBox->GetItemId(rIdent), rHelpId);
1022 }
1023
1024 bool SalInstanceToolbar::get_item_visible(const OUString& rIdent) const
1025 {
1026 return m_xToolBox->IsItemVisible(m_xToolBox->GetItemId(rIdent));
1027 }
1028
1029 void SalInstanceToolbar::set_item_active(const OUString& rIdent, bool bActive)
1030 {
1031 ToolBoxItemId nItemId = m_xToolBox->GetItemId(rIdent);
1032 m_xToolBox->CheckItem(nItemId, bActive);
1033 }
1034
1035 bool SalInstanceToolbar::get_item_active(const OUString& rIdent) const
1036 {
1037 return m_xToolBox->IsItemChecked(m_xToolBox->GetItemId(rIdent));
1038 }
1039
1040 void SalInstanceToolbar::set_menu_item_active(const OUString& rIdent, bool bActive)
1041 {
1042 ToolBoxItemId nItemId = m_xToolBox->GetItemId(rIdent);
1043 assert(m_xToolBox->GetItemBits(nItemId) & ToolBoxItemBits::DROPDOWN);
1044
1045 if (bActive)
1046 {
1047 m_sStartShowIdent = m_xToolBox->GetItemCommand(nItemId);
1048 signal_toggle_menu(m_sStartShowIdent);
1049 }
1050
1051 auto pFloat = m_aFloats[nItemId];
1052 if (pFloat)
1053 {
1054 if (bActive)
1055 vcl::Window::GetDockingManager()->StartPopupMode(m_xToolBox, pFloat,
1056 FloatWinPopupFlags::GrabFocus);
1057 else
1058 vcl::Window::GetDockingManager()->EndPopupMode(pFloat);
1059 }
1060 auto pPopup = m_aMenus[nItemId];
1061 if (pPopup)
1062 {
1063 if (bActive)
1064 {
1065 tools::Rectangle aRect = m_xToolBox->GetItemRect(nItemId);
1066 pPopup->Execute(m_xToolBox, aRect, PopupMenuFlags::ExecuteDown);
1067 }
1068 else
1069 pPopup->EndExecute();
1070 }
1071
1072 m_sStartShowIdent.clear();
1073 }
1074
1075 bool SalInstanceToolbar::get_menu_item_active(const OUString& rIdent) const
1076 {
1077 ToolBoxItemId nItemId = m_xToolBox->GetItemId(rIdent);
1078 assert(m_xToolBox->GetItemBits(nItemId) & ToolBoxItemBits::DROPDOWN);
1079
1080 if (rIdent == m_sStartShowIdent)
1081 return true;
1082
1083 auto aFloat = m_aFloats.find(nItemId);
1084 if (aFloat != m_aFloats.end())
1085 {
1086 return vcl::Window::GetDockingManager()->IsInPopupMode(aFloat->second);
1087 }
1088
1089 auto aPopup = m_aMenus.find(nItemId);
1090 if (aPopup != m_aMenus.end())
1091 {
1092 return PopupMenu::GetActivePopupMenu() == aPopup->second;
1093 }
1094
1095 return false;
1096 }
1097
1098 void SalInstanceToolbar::set_item_popover(const OUString& rIdent, weld::Widget* pPopover)
1099 {
1100 SalInstanceWidget* pPopoverWidget = dynamic_cast<SalInstanceWidget*>(pPopover);
1101
1102 vcl::Window* pFloat = pPopoverWidget ? pPopoverWidget->getWidget() : nullptr;
1103 if (pFloat)
1104 {
1105 pFloat->AddEventListener(LINK(this, SalInstanceToolbar, MenuToggleListener));
1106 pFloat->EnableDocking();
1107 }
1108
1109 ToolBoxItemId nId = m_xToolBox->GetItemId(rIdent);
1110 auto xOldFloat = m_aFloats[nId];
1111 if (xOldFloat)
1112 {
1113 xOldFloat->RemoveEventListener(LINK(this, SalInstanceToolbar, MenuToggleListener));
1114 }
1115 m_aFloats[nId] = pFloat;
1116 m_aMenus[nId] = nullptr;
1117 }
1118
1119 void SalInstanceToolbar::set_item_menu(const OUString& rIdent, weld::Menu* pMenu)
1120 {
1121 SalInstanceMenu* pInstanceMenu = dynamic_cast<SalInstanceMenu*>(pMenu);
1122
1123 PopupMenu* pPopup = pInstanceMenu ? pInstanceMenu->getMenu() : nullptr;
1124
1125 ToolBoxItemId nId = m_xToolBox->GetItemId(rIdent);
1126 m_aMenus[nId] = pPopup;
1127 m_aFloats[nId] = nullptr;
1128 }
1129
1130 void SalInstanceToolbar::insert_item(int pos, const OUString& rId)
1131 {
1132 ToolBoxItemId nId(pos);
1133 m_xToolBox->InsertItem(nId, OUString(), rId, ToolBoxItemBits::ICON_ONLY);
1134 }
1135
1136 void SalInstanceToolbar::insert_separator(int pos, const OUString& /*rId*/)
1137 {
1138 auto nInsertPos = pos == -1 ? ToolBox::APPEND : pos;
1139 m_xToolBox->InsertSeparator(nInsertPos, 5);
1140 }
1141
1142 int SalInstanceToolbar::get_n_items() const { return m_xToolBox->GetItemCount(); }
1143
1144 OUString SalInstanceToolbar::get_item_ident(int nIndex) const
1145 {
1146 return m_xToolBox->GetItemCommand(m_xToolBox->GetItemId(nIndex));
1147 }
1148
1149 void SalInstanceToolbar::set_item_ident(int nIndex, const OUString& rIdent)
1150 {
1151 return m_xToolBox->SetItemCommand(m_xToolBox->GetItemId(nIndex), rIdent);
1152 }
1153
1154 void SalInstanceToolbar::set_item_label(int nIndex, const OUString& rLabel)
1155 {
1156 m_xToolBox->SetItemText(m_xToolBox->GetItemId(nIndex), rLabel);
1157 }
1158
1159 OUString SalInstanceToolbar::get_item_label(const OUString& rIdent) const
1160 {
1161 return m_xToolBox->GetItemText(m_xToolBox->GetItemId(rIdent));
1162 }
1163
1164 void SalInstanceToolbar::set_item_label(const OUString& rIdent, const OUString& rLabel)
1165 {
1166 m_xToolBox->SetItemText(m_xToolBox->GetItemId(rIdent), rLabel);
1167 }
1168
1169 void SalInstanceToolbar::set_item_icon_name(const OUString& rIdent, const OUString& rIconName)
1170 {
1171 m_xToolBox->SetItemImage(m_xToolBox->GetItemId(rIdent), Image(StockImage::Yes, rIconName));
1172 }
1173
1174 void SalInstanceToolbar::set_item_image_mirrored(const OUString& rIdent, bool bMirrored)
1175 {
1176 m_xToolBox->SetItemImageMirrorMode(m_xToolBox->GetItemId(rIdent), bMirrored);
1177 }
1178
1179 void SalInstanceToolbar::set_item_image(const OUString& rIdent,
1180 const css::uno::Reference<css::graphic::XGraphic>& rIcon)
1181 {
1182 m_xToolBox->SetItemImage(m_xToolBox->GetItemId(rIdent), Image(rIcon));
1183 }
1184
1185 void SalInstanceToolbar::set_item_image(const OUString& rIdent, VirtualDevice* pDevice)
1186 {
1187 if (pDevice)
1188 m_xToolBox->SetItemImage(m_xToolBox->GetItemId(rIdent), createImage(*pDevice));
1189 else
1190 m_xToolBox->SetItemImage(m_xToolBox->GetItemId(rIdent), Image());
1191 }
1192
1193 void SalInstanceToolbar::set_item_image(int nIndex,
1194 const css::uno::Reference<css::graphic::XGraphic>& rIcon)
1195 {
1196 m_xToolBox->SetItemImage(m_xToolBox->GetItemId(nIndex), Image(rIcon));
1197 }
1198
1199 void SalInstanceToolbar::set_item_tooltip_text(int nIndex, const OUString& rTip)
1200 {
1201 m_xToolBox->SetQuickHelpText(m_xToolBox->GetItemId(nIndex), rTip);
1202 }
1203
1204 void SalInstanceToolbar::set_item_tooltip_text(const OUString& rIdent, const OUString& rTip)
1205 {
1206 m_xToolBox->SetQuickHelpText(m_xToolBox->GetItemId(rIdent), rTip);
1207 }
1208
1209 OUString SalInstanceToolbar::get_item_tooltip_text(const OUString& rIdent) const
1210 {
1211 return m_xToolBox->GetQuickHelpText(m_xToolBox->GetItemId(rIdent));
1212 }
1213
1214 vcl::ImageType SalInstanceToolbar::get_icon_size() const { return m_xToolBox->GetImageSize(); }
1215
1216 void SalInstanceToolbar::set_icon_size(vcl::ImageType eType)
1217 {
1218 ToolBoxButtonSize eButtonSize = ToolBoxButtonSize::DontCare;
1219 switch (eType)
1220 {
1221 case vcl::ImageType::Size16:
1222 eButtonSize = ToolBoxButtonSize::Small;
1223 break;
1224 case vcl::ImageType::Size26:
1225 eButtonSize = ToolBoxButtonSize::Large;
1226 break;
1227 case vcl::ImageType::Size32:
1228 eButtonSize = ToolBoxButtonSize::Size32;
1229 break;
1230 }
1231 if (m_xToolBox->GetToolboxButtonSize() != eButtonSize)
1232 {
1233 m_xToolBox->SetToolboxButtonSize(eButtonSize);
1234 m_xToolBox->queue_resize();
1235 }
1236 }
1237
1238 sal_uInt16 SalInstanceToolbar::get_modifier_state() const { return m_xToolBox->GetModifier(); }
1239
1240 int SalInstanceToolbar::get_drop_index(const Point& rPoint) const
1241 {
1242 auto nRet = m_xToolBox->GetItemPos(rPoint);
1243 if (nRet == ToolBox::ITEM_NOTFOUND)
1244 return 0;
1245 return nRet;
1246 }
1247
1248 SalInstanceToolbar::~SalInstanceToolbar()
1249 {
1250 m_xToolBox->SetDropdownClickHdl(Link<ToolBox*, void>());
1251 m_xToolBox->SetSelectHdl(Link<ToolBox*, void>());
1252 }
1253
1254 IMPL_LINK_NOARG(SalInstanceToolbar, ClickHdl, ToolBox*, void)
1255 {
1256 ToolBoxItemId nItemId = m_xToolBox->GetCurItemId();
1257 signal_clicked(m_xToolBox->GetItemCommand(nItemId));
1258 }
1259
1260 IMPL_LINK_NOARG(SalInstanceToolbar, DropdownClick, ToolBox*, void)
1261 {
1262 ToolBoxItemId nItemId = m_xToolBox->GetCurItemId();
1263 set_menu_item_active(m_xToolBox->GetItemCommand(nItemId), true);
1264 }
1265
1266 IMPL_LINK(SalInstanceToolbar, MenuToggleListener, VclWindowEvent&, rEvent, void)
1267 {
1268 if (rEvent.GetId() == VclEventId::WindowEndPopupMode)
1269 {
1270 for (const auto& rFloat : m_aFloats)
1271 {
1272 if (rEvent.GetWindow() == rFloat.second)
1273 {
1274 ToolBoxItemId nItemId = rFloat.first;
1275 signal_toggle_menu(m_xToolBox->GetItemCommand(nItemId));
1276 break;
1277 }
1278 }
1279 }
1280 }
1281
1282 namespace
1283 {
1284 class SalInstanceSizeGroup : public weld::SizeGroup
1285 {
1286 private:
1287 std::shared_ptr<VclSizeGroup> m_xGroup;
1288
1289 public:
1290 SalInstanceSizeGroup()
1291 : m_xGroup(std::make_shared<VclSizeGroup>())
1292 {
1293 }
1294 virtual void add_widget(weld::Widget* pWidget) override
1295 {
1296 SalInstanceWidget* pVclWidget = dynamic_cast<SalInstanceWidget*>(pWidget);
1297 assert(pVclWidget && pVclWidget->getWidget());
1298 pVclWidget->getWidget()->add_to_size_group(m_xGroup);
1299 }
1300 virtual void set_mode(VclSizeGroupMode eMode) override { m_xGroup->set_mode(eMode); }
1301 };
1302 }
1303
1304 void SalInstanceContainer::connect_container_focus_changed(const Link<Container&, void>& rLink)
1305 {
1306 ensure_event_listener();
1307 weld::Container::connect_container_focus_changed(rLink);
1308 }
1309
1310 void SalInstanceContainer::HandleEventListener(VclWindowEvent& rEvent)
1311 {
1312 if (rEvent.GetId() == VclEventId::WindowActivate
1313 || rEvent.GetId() == VclEventId::WindowDeactivate)
1314 {
1315 signal_container_focus_changed();
1316 return;
1317 }
1318 SalInstanceWidget::HandleEventListener(rEvent);
1319 }
1320
1321 SalInstanceContainer::SalInstanceContainer(vcl::Window* pContainer, SalInstanceBuilder* pBuilder,
1322 bool bTakeOwnership)
1323 : SalInstanceWidget(pContainer, pBuilder, bTakeOwnership)
1324 , m_xContainer(pContainer)
1325 {
1326 }
1327
1328 void SalInstanceContainer::move(weld::Widget* pWidget, weld::Container* pNewParent)
1329 {
1330 SalInstanceWidget* pVclWidget = dynamic_cast<SalInstanceWidget*>(pWidget);
1331 assert(pVclWidget);
1332 SalInstanceContainer* pNewVclParent = dynamic_cast<SalInstanceContainer*>(pNewParent);
1333 assert(!pNewParent || pNewVclParent);
1334 vcl::Window* pVclWindow = pVclWidget->getWidget();
1335 if (pNewVclParent)
1336 {
1337 vcl::Window* pNew = pNewVclParent->getWidget();
1338 if (!pNew->isDisposed())
1339 pVclWindow->SetParent(pNewVclParent->getWidget());
1340 else
1341 SAL_WARN("vcl", "ignoring move because new parent is already disposed");
1342 }
1343 else
1344 {
1345 pVclWindow->Hide();
1346 pVclWindow->SetParent(ImplGetDefaultWindow());
1347 }
1348 }
1349
1350 void SalInstanceContainer::child_grab_focus()
1351 {
1352 m_xContainer->GrabFocus();
1353 if (vcl::Window* pFirstChild = m_xContainer->ImplGetDlgWindow(0, GetDlgWindowType::First))
1354 pFirstChild->ImplControlFocus();
1355 }
1356
1357 css::uno::Reference<css::awt::XWindow> SalInstanceContainer::CreateChildFrame()
1358 {
1359 auto xPage = VclPtr<VclBin>::Create(m_xContainer.get());
1360 xPage->set_expand(true);
1361 xPage->Show();
1362 return css::uno::Reference<css::awt::XWindow>(xPage->GetComponentInterface(),
1363 css::uno::UNO_QUERY);
1364 }
1365
1366 std::unique_ptr<weld::Container> SalInstanceWidget::weld_parent() const
1367 {
1368 vcl::Window* pParent = m_xWidget->GetParent();
1369 if (!pParent)
1370 return nullptr;
1371 return std::make_unique<SalInstanceContainer>(pParent, m_pBuilder, false);
1372 }
1373
1374 void SalInstanceWidget::DoRecursivePaint(vcl::Window* pWindow, const Point& rRenderLogicPos,
1375 OutputDevice& rOutput)
1376 {
1377 rOutput.Push();
1378 bool bOldMapModeEnabled = pWindow->IsMapModeEnabled();
1379
1380 if (pWindow->GetMapMode().GetMapUnit() != rOutput.GetMapMode().GetMapUnit())
1381 {
1382 // This is needed for e.g. the scrollbar in writer comments in margins that has its map unit in pixels
1383 // as seen with bin/run gtktiledviewer --enable-tiled-annotations on a document containing a comment
1384 // long enough to need a scrollbar
1385 pWindow->EnableMapMode();
1386 MapMode aMapMode = pWindow->GetMapMode();
1387 aMapMode.SetMapUnit(rOutput.GetMapMode().GetMapUnit());
1388 aMapMode.SetScaleX(rOutput.GetMapMode().GetScaleX());
1389 aMapMode.SetScaleY(rOutput.GetMapMode().GetScaleY());
1390 pWindow->SetMapMode(aMapMode);
1391 }
1392
1393 VclPtr<VirtualDevice> xOutput(VclPtr<VirtualDevice>::Create(DeviceFormat::WITHOUT_ALPHA));
1394 Size aChildSizePixel(pWindow->GetSizePixel());
1395 xOutput->SetOutputSizePixel(aChildSizePixel);
1396
1397 MapMode aMapMode(xOutput->GetMapMode());
1398 aMapMode.SetMapUnit(rOutput.GetMapMode().GetMapUnit());
1399 aMapMode.SetScaleX(rOutput.GetMapMode().GetScaleX());
1400 aMapMode.SetScaleY(rOutput.GetMapMode().GetScaleY());
1401 xOutput->SetMapMode(aMapMode);
1402
1403 Size aTempLogicSize(xOutput->PixelToLogic(aChildSizePixel));
1404 Size aRenderLogicSize(rOutput.PixelToLogic(aChildSizePixel));
1405
1406 switch (rOutput.GetOutDevType())
1407 {
1408 case OUTDEV_WINDOW:
1409 case OUTDEV_VIRDEV:
1410 xOutput->DrawOutDev(Point(), aTempLogicSize, rRenderLogicPos, aRenderLogicSize,
1411 rOutput);
1412 break;
1413 case OUTDEV_PRINTER:
1414 case OUTDEV_PDF:
1415 xOutput->SetBackground(rOutput.GetBackground());
1416 xOutput->Erase();
1417 break;
1418 }
1419
1420 //set ReallyVisible to match Visible, we restore the original state after Paint
1421 WindowImpl* pImpl = pWindow->ImplGetWindowImpl();
1422 bool bRVisible = pImpl->mbReallyVisible;
1423 pImpl->mbReallyVisible = pWindow->IsVisible();
1424
1425 pWindow->ApplySettings(*xOutput);
1426 pWindow->Paint(*xOutput, tools::Rectangle(Point(), pWindow->PixelToLogic(aChildSizePixel)));
1427
1428 pImpl->mbReallyVisible = bRVisible;
1429
1430 switch (rOutput.GetOutDevType())
1431 {
1432 case OUTDEV_WINDOW:
1433 case OUTDEV_VIRDEV:
1434 rOutput.DrawOutDev(rRenderLogicPos, aRenderLogicSize, Point(), aTempLogicSize,
1435 *xOutput);
1436 break;
1437 case OUTDEV_PRINTER:
1438 case OUTDEV_PDF:
1439 rOutput.DrawBitmapEx(rRenderLogicPos, aRenderLogicSize,
1440 xOutput->GetBitmapEx(Point(), aTempLogicSize));
1441 break;
1442 }
1443
1444 bool bHasMirroredGraphics = pWindow->GetOutDev()->HasMirroredGraphics();
1445
1446 xOutput.disposeAndClear();
1447
1448 pWindow->EnableMapMode(bOldMapModeEnabled);
1449 rOutput.Pop();
1450
1451 for (vcl::Window* pChild = pWindow->GetWindow(GetWindowType::FirstChild); pChild;
1452 pChild = pChild->GetWindow(GetWindowType::Next))
1453 {
1454 if (!pChild->IsVisible())
1455 continue;
1456
1457 tools::Long nDeltaX
1458 = pChild->GetOutDev()->GetOutOffXPixel() - pWindow->GetOutDev()->GetOutOffXPixel();
1459 if (bHasMirroredGraphics)
1460 nDeltaX = pWindow->GetOutDev()->GetOutputWidthPixel() - nDeltaX
1461 - pChild->GetOutDev()->GetOutputWidthPixel();
1462
1463 tools::Long nDeltaY
1464 = pChild->GetOutDev()->GetOutOffYPixel() - pWindow->GetOutDev()->GetOutOffYPixel();
1465
1466 Point aPos(rRenderLogicPos);
1467 aPos += Point(nDeltaX, nDeltaY);
1468
1469 DoRecursivePaint(pChild, aPos, rOutput);
1470 }
1471 }
1472
1473 void SalInstanceWidget::draw(OutputDevice& rOutput, const Point& rPos, const Size& rSizePixel)
1474 {
1475 Size aOrigSize(m_xWidget->GetSizePixel());
1476 bool bChangeSize = aOrigSize != rSizePixel;
1477 if (bChangeSize)
1478 m_xWidget->SetSizePixel(rSizePixel);
1479
1480 DoRecursivePaint(m_xWidget, rPos, rOutput);
1481
1482 if (bChangeSize)
1483 m_xWidget->SetSizePixel(aOrigSize);
1484 }
1485
1486 SalInstanceBox::SalInstanceBox(VclBox* pContainer, SalInstanceBuilder* pBuilder,
1487 bool bTakeOwnership)
1488 : SalInstanceContainer(pContainer, pBuilder, bTakeOwnership)
1489 , m_xBox(pContainer)
1490 {
1491 }
1492 void SalInstanceBox::reorder_child(weld::Widget* pWidget, int nNewPosition)
1493 {
1494 SalInstanceWidget* pVclWidget = dynamic_cast<SalInstanceWidget*>(pWidget);
1495 assert(pVclWidget);
1496 pVclWidget->getWidget()->reorderWithinParent(nNewPosition);
1497 }
1498
1499 void SalInstanceBox::sort_native_button_order() { ::sort_native_button_order(*m_xBox); }
1500
1501 namespace
1502 {
1503 void CollectChildren(const vcl::Window& rCurrent, const basegfx::B2IPoint& rTopLeft,
1504 weld::ScreenShotCollection& rControlDataCollection)
1505 {
1506 if (!rCurrent.IsVisible())
1507 return;
1508
1509 const Point aCurrentPos(rCurrent.GetPosPixel());
1510 const Size aCurrentSize(rCurrent.GetSizePixel());
1511 const basegfx::B2IPoint aCurrentTopLeft(rTopLeft.getX() + aCurrentPos.X(),
1512 rTopLeft.getY() + aCurrentPos.Y());
1513 const basegfx::B2IRange aCurrentRange(
1514 aCurrentTopLeft,
1515 aCurrentTopLeft + basegfx::B2IPoint(aCurrentSize.Width(), aCurrentSize.Height()));
1516
1517 if (!aCurrentRange.isEmpty())
1518 {
1519 rControlDataCollection.emplace_back(rCurrent.GetHelpId(), aCurrentRange);
1520 }
1521
1522 for (sal_uInt16 a(0); a < rCurrent.GetChildCount(); a++)
1523 {
1524 vcl::Window* pChild = rCurrent.GetChild(a);
1525 if (nullptr != pChild)
1526 {
1527 CollectChildren(*pChild, aCurrentTopLeft, rControlDataCollection);
1528 }
1529 }
1530 }
1531 }
1532
1533 void SalInstanceWindow::override_child_help(vcl::Window* pParent)
1534 {
1535 for (vcl::Window* pChild = pParent->GetWindow(GetWindowType::FirstChild); pChild;
1536 pChild = pChild->GetWindow(GetWindowType::Next))
1537 override_child_help(pChild);
1538 pParent->SetHelpHdl(LINK(this, SalInstanceWindow, HelpHdl));
1539 }
1540
1541 void SalInstanceWindow::clear_child_help(vcl::Window* pParent)
1542 {
1543 for (vcl::Window* pChild = pParent->GetWindow(GetWindowType::FirstChild); pChild;
1544 pChild = pChild->GetWindow(GetWindowType::Next))
1545 clear_child_help(pChild);
1546 pParent->SetHelpHdl(Link<vcl::Window&, bool>());
1547 }
1548
1549 SalInstanceWindow::SalInstanceWindow(vcl::Window* pWindow, SalInstanceBuilder* pBuilder,
1550 bool bTakeOwnership)
1551 : SalInstanceContainer(pWindow, pBuilder, bTakeOwnership)
1552 , m_xWindow(pWindow)
1553 {
1554 // tdf#129745 only override child help for the normal case, not for
1555 // m_pBuilder of null which is the toplevel application frame case.
1556 if (m_pBuilder)
1557 override_child_help(m_xWindow);
1558 }
1559
1560 void SalInstanceWindow::set_title(const OUString& rTitle) { m_xWindow->SetText(rTitle); }
1561
1562 OUString SalInstanceWindow::get_title() const { return m_xWindow->GetText(); }
1563
1564 css::uno::Reference<css::awt::XWindow> SalInstanceWindow::GetXWindow()
1565 {
1566 css::uno::Reference<css::awt::XWindow> xWindow(m_xWindow->GetComponentInterface(),
1567 css::uno::UNO_QUERY);
1568 return xWindow;
1569 }
1570
1571 namespace
1572 {
1573 void resize_to_request(vcl::Window* pWindow)
1574 {
1575 if (SystemWindow* pSysWin = dynamic_cast<SystemWindow*>(pWindow))
1576 {
1577 pSysWin->setOptimalLayoutSize(true);
1578 return;
1579 }
1580 if (DockingWindow* pDockWin = dynamic_cast<DockingWindow*>(pWindow))
1581 {
1582 pDockWin->setOptimalLayoutSize();
1583 return;
1584 }
1585 assert(false && "must be system or docking window");
1586 }
1587 }
1588
1589 void SalInstanceWindow::resize_to_request() { ::resize_to_request(m_xWindow.get()); }
1590
1591 void SalInstanceWindow::set_modal(bool bModal) { m_xWindow->ImplGetFrame()->SetModal(bModal); }
1592
1593 bool SalInstanceWindow::get_modal() const { return m_xWindow->ImplGetFrame()->GetModal(); }
1594
1595 void SalInstanceWindow::window_move(int x, int y) { m_xWindow->SetPosPixel(Point(x, y)); }
1596
1597 Size SalInstanceWindow::get_size() const { return m_xWindow->GetSizePixel(); }
1598
1599 Point SalInstanceWindow::get_position() const { return m_xWindow->GetPosPixel(); }
1600
1601 tools::Rectangle SalInstanceWindow::get_monitor_workarea() const
1602 {
1603 return m_xWindow->GetDesktopRectPixel();
1604 }
1605
1606 void SalInstanceWindow::set_centered_on_parent(bool /*bTrackGeometryRequests*/)
1607 {
1608 if (vcl::Window* pParent = m_xWidget->GetParent())
1609 {
1610 Size aParentGeometry(pParent->GetSizePixel());
1611 Size aGeometry(m_xWidget->get_preferred_size());
1612 auto nX = (aParentGeometry.Width() - aGeometry.Width()) / 2;
1613 auto nY = (aParentGeometry.Height() - aGeometry.Height()) / 2;
1614 m_xWidget->SetPosPixel(Point(nX, nY));
1615 }
1616 }
1617
1618 bool SalInstanceWindow::get_resizable() const { return m_xWindow->GetStyle() & WB_SIZEABLE; }
1619
1620 bool SalInstanceWindow::has_toplevel_focus() const { return m_xWindow->HasChildPathFocus(); }
1621
1622 void SalInstanceWindow::present()
1623 {
1624 m_xWindow->ToTop(ToTopFlags::RestoreWhenMin | ToTopFlags::ForegroundTask);
1625 }
1626
1627 void SalInstanceWindow::implResetDefault(const vcl::Window* _pWindow)
1628 {
1629 vcl::Window* pChildLoop = _pWindow->GetWindow(GetWindowType::FirstChild);
1630 while (pChildLoop)
1631 {
1632 // does the window participate in the tabbing order?
1633 if (pChildLoop->GetStyle() & WB_DIALOGCONTROL)
1634 implResetDefault(pChildLoop);
1635
1636 // is it a button?
1637 WindowType eType = pChildLoop->GetType();
1638 if ((WindowType::PUSHBUTTON == eType) || (WindowType::OKBUTTON == eType)
1639 || (WindowType::CANCELBUTTON == eType) || (WindowType::HELPBUTTON == eType)
1640 || (WindowType::IMAGEBUTTON == eType) || (WindowType::MENUBUTTON == eType)
1641 || (WindowType::MOREBUTTON == eType))
1642 {
1643 pChildLoop->SetStyle(pChildLoop->GetStyle() & ~WB_DEFBUTTON);
1644 }
1645
1646 // the next one ...
1647 pChildLoop = pChildLoop->GetWindow(GetWindowType::Next);
1648 }
1649 }
1650
1651 void SalInstanceWindow::recursively_unset_default_buttons() { implResetDefault(m_xWindow.get()); }
1652
1653 void SalInstanceWindow::change_default_widget(weld::Widget* pOld, weld::Widget* pNew)
1654 {
1655 SalInstanceWidget* pVclNew = dynamic_cast<SalInstanceWidget*>(pNew);
1656 vcl::Window* pWidgetNew = pVclNew ? pVclNew->getWidget() : nullptr;
1657 SalInstanceWidget* pVclOld = dynamic_cast<SalInstanceWidget*>(pOld);
1658 vcl::Window* pWidgetOld = pVclOld ? pVclOld->getWidget() : nullptr;
1659 if (pWidgetOld)
1660 pWidgetOld->set_property("has-default", OUString::boolean(false));
1661 else
1662 recursively_unset_default_buttons();
1663 if (pWidgetNew)
1664 pWidgetNew->set_property("has-default", OUString::boolean(true));
1665 }
1666
1667 bool SalInstanceWindow::is_default_widget(const weld::Widget* pCandidate) const
1668 {
1669 const SalInstanceWidget* pVclCandidate = dynamic_cast<const SalInstanceWidget*>(pCandidate);
1670 vcl::Window* pWidget = pVclCandidate ? pVclCandidate->getWidget() : nullptr;
1671 return pWidget && pWidget->GetStyle() & WB_DEFBUTTON;
1672 }
1673
1674 void SalInstanceWindow::set_window_state(const OUString& rStr)
1675 {
1676 SystemWindow* pSysWin = dynamic_cast<SystemWindow*>(m_xWindow.get());
1677 assert(pSysWin);
1678 pSysWin->SetWindowState(rStr);
1679 }
1680
1681 OUString SalInstanceWindow::get_window_state(vcl::WindowDataMask nMask) const
1682 {
1683 SystemWindow* pSysWin = dynamic_cast<SystemWindow*>(m_xWindow.get());
1684 assert(pSysWin);
1685 return pSysWin->GetWindowState(nMask);
1686 }
1687
1688 SystemEnvData SalInstanceWindow::get_system_data() const { return *m_xWindow->GetSystemData(); }
1689
1690 VclPtr<VirtualDevice> SalInstanceWindow::screenshot()
1691 {
1692 SystemWindow* pSysWin = dynamic_cast<SystemWindow*>(m_xWindow.get());
1693 assert(pSysWin);
1694 return pSysWin->createScreenshot();
1695 }
1696
1697 weld::ScreenShotCollection SalInstanceWindow::collect_screenshot_data()
1698 {
1699 weld::ScreenShotCollection aRet;
1700
1701 // collect all children. Choose start pos to be negative
1702 // of target dialog's position to get all positions relative to (0,0)
1703 const Point aParentPos(m_xWindow->GetPosPixel());
1704 const basegfx::B2IPoint aTopLeft(-aParentPos.X(), -aParentPos.Y());
1705 CollectChildren(*m_xWindow, aTopLeft, aRet);
1706
1707 return aRet;
1708 }
1709
1710 const vcl::ILibreOfficeKitNotifier* SalInstanceWindow::GetLOKNotifier()
1711 {
1712 return m_xWindow ? m_xWindow->GetLOKNotifier() : nullptr;
1713 }
1714
1715 SalInstanceWindow::~SalInstanceWindow()
1716 {
1717 // tdf#129745 only undo overriding child help for the normal case, not for
1718 // m_pBuilder of null which is the toplevel application frame case.
1719 if (m_pBuilder)
1720 clear_child_help(m_xWindow);
1721 }
1722
1723 IMPL_LINK_NOARG(SalInstanceWindow, HelpHdl, vcl::Window&, bool)
1724 {
1725 help();
1726 return false;
1727 }
1728
1729 typedef std::set<VclPtr<vcl::Window>> winset;
1730
1731 namespace
1732 {
1733 void hideUnless(const vcl::Window* pTop, const winset& rVisibleWidgets,
1734 std::vector<VclPtr<vcl::Window>>& rWasVisibleWidgets)
1735 {
1736 for (vcl::Window* pChild = pTop->GetWindow(GetWindowType::FirstChild); pChild;
1737 pChild = pChild->GetWindow(GetWindowType::Next))
1738 {
1739 if (!pChild->IsVisible())
1740 continue;
1741 if (rVisibleWidgets.find(pChild) == rVisibleWidgets.end())
1742 {
1743 rWasVisibleWidgets.emplace_back(pChild);
1744 pChild->Hide();
1745 }
1746 else if (isContainerWindow(pChild))
1747 {
1748 hideUnless(pChild, rVisibleWidgets, rWasVisibleWidgets);
1749 }
1750 }
1751 }
1752 }
1753
1754 SalInstanceDialog::SalInstanceDialog(::Dialog* pDialog, SalInstanceBuilder* pBuilder,
1755 bool bTakeOwnership)
1756 : SalInstanceWindow(pDialog, pBuilder, bTakeOwnership)
1757 , m_xDialog(pDialog)
1758 , m_nOldEditWidthReq(0)
1759 , m_nOldBorderWidth(0)
1760 {
1761 const bool bScreenshotMode(officecfg::Office::Common::Misc::ScreenshotMode::get());
1762 if (bScreenshotMode)
1763 {
1764 m_xDialog->SetPopupMenuHdl(LINK(this, SalInstanceDialog, PopupScreenShotMenuHdl));
1765 }
1766 }
1767
1768 bool SalInstanceDialog::runAsync(std::shared_ptr<weld::DialogController> aOwner,
1769 const std::function<void(sal_Int32)>& rEndDialogFn)
1770 {
1771 VclAbstractDialog::AsyncContext aCtx;
1772 aCtx.mxOwnerDialogController = aOwner;
1773 aCtx.maEndDialogFn = rEndDialogFn;
1774 VclButtonBox* pActionArea = m_xDialog->get_action_area();
1775 if (pActionArea)
1776 sort_native_button_order(*pActionArea);
1777 return m_xDialog->StartExecuteAsync(aCtx);
1778 }
1779
1780 bool SalInstanceDialog::runAsync(std::shared_ptr<Dialog> const& rxSelf,
1781 const std::function<void(sal_Int32)>& rEndDialogFn)
1782 {
1783 assert(rxSelf.get() == this);
1784 VclAbstractDialog::AsyncContext aCtx;
1785 // In order to store a shared_ptr to ourself, we have to have been constructed by make_shared,
1786 // which is that rxSelf enforces.
1787 aCtx.mxOwnerSelf = rxSelf;
1788 aCtx.maEndDialogFn = rEndDialogFn;
1789 VclButtonBox* pActionArea = m_xDialog->get_action_area();
1790 if (pActionArea)
1791 sort_native_button_order(*pActionArea);
1792 return m_xDialog->StartExecuteAsync(aCtx);
1793 }
1794
1795 void SalInstanceDialog::collapse(weld::Widget* pEdit, weld::Widget* pButton)
1796 {
1797 SalInstanceWidget* pVclEdit = dynamic_cast<SalInstanceWidget*>(pEdit);
1798 assert(pVclEdit);
1799 SalInstanceWidget* pVclButton = dynamic_cast<SalInstanceWidget*>(pButton);
1800
1801 vcl::Window* pRefEdit = pVclEdit->getWidget();
1802 vcl::Window* pRefBtn = pVclButton ? pVclButton->getWidget() : nullptr;
1803
1804 auto nOldEditWidth = pRefEdit->GetSizePixel().Width();
1805 m_nOldEditWidthReq = pRefEdit->get_width_request();
1806
1807 //We want just pRefBtn and pRefEdit to be shown
1808 //mark widgets we want to be visible, starting with pRefEdit
1809 //and all its direct parents.
1810 winset aVisibleWidgets;
1811 vcl::Window* pContentArea = m_xDialog->get_content_area();
1812 for (vcl::Window* pCandidate = pRefEdit;
1813 pCandidate && (pCandidate != pContentArea && pCandidate->IsVisible());
1814 pCandidate = pCandidate->GetWindow(GetWindowType::RealParent))
1815 {
1816 aVisibleWidgets.insert(pCandidate);
1817 }
1818 //same again with pRefBtn, except stop if there's a
1819 //shared parent in the existing widgets
1820 for (vcl::Window* pCandidate = pRefBtn;
1821 pCandidate && (pCandidate != pContentArea && pCandidate->IsVisible());
1822 pCandidate = pCandidate->GetWindow(GetWindowType::RealParent))
1823 {
1824 if (aVisibleWidgets.insert(pCandidate).second)
1825 break;
1826 }
1827
1828 //hide everything except the aVisibleWidgets
1829 hideUnless(pContentArea, aVisibleWidgets, m_aHiddenWidgets);
1830
1831 // the insert function case has an initially hidden edit widget, so it has
1832 // not start size, so take larger of actual size and size request
1833 pRefEdit->set_width_request(std::max(nOldEditWidth, m_nOldEditWidthReq));
1834 m_nOldBorderWidth = m_xDialog->get_border_width();
1835 m_xDialog->set_border_width(0);
1836 if (vcl::Window* pActionArea = m_xDialog->get_action_area())
1837 pActionArea->Hide();
1838 m_xDialog->setOptimalLayoutSize(true);
1839 m_xRefEdit = pRefEdit;
1840 }
1841
1842 void SalInstanceDialog::undo_collapse()
1843 {
1844 // All others: Show();
1845 for (VclPtr<vcl::Window> const& pWindow : m_aHiddenWidgets)
1846 {
1847 pWindow->Show();
1848 }
1849 m_aHiddenWidgets.clear();
1850
1851 m_xRefEdit->set_width_request(m_nOldEditWidthReq);
1852 m_xRefEdit.clear();
1853 m_xDialog->set_border_width(m_nOldBorderWidth);
1854 if (vcl::Window* pActionArea = m_xDialog->get_action_area())
1855 pActionArea->Show();
1856 m_xDialog->setOptimalLayoutSize(true);
1857 }
1858
1859 void SalInstanceDialog::SetInstallLOKNotifierHdl(
1860 const Link<void*, vcl::ILibreOfficeKitNotifier*>& rLink)
1861 {
1862 m_xDialog->SetInstallLOKNotifierHdl(rLink);
1863 }
1864
1865 int SalInstanceDialog::run()
1866 {
1867 VclButtonBox* pActionArea = m_xDialog->get_action_area();
1868 if (pActionArea)
1869 sort_native_button_order(*pActionArea);
1870 return m_xDialog->Execute();
1871 }
1872
1873 void SalInstanceDialog::response(int nResponse) { m_xDialog->EndDialog(nResponse); }
1874
1875 void SalInstanceDialog::add_button(const OUString& rText, int nResponse, const OUString& rHelpId)
1876 {
1877 VclButtonBox* pBox = m_xDialog->get_action_area();
1878 VclPtr<PushButton> xButton(
1879 VclPtr<PushButton>::Create(pBox, WB_CLIPCHILDREN | WB_CENTER | WB_VCENTER));
1880 xButton->SetText(rText);
1881 xButton->SetHelpId(rHelpId);
1882
1883 switch (nResponse)
1884 {
1885 case RET_OK:
1886 xButton->set_id("ok");
1887 break;
1888 case RET_CLOSE:
1889 xButton->set_id("close");
1890 break;
1891 case RET_CANCEL:
1892 xButton->set_id("cancel");
1893 break;
1894 case RET_YES:
1895 xButton->set_id("yes");
1896 break;
1897 case RET_NO:
1898 xButton->set_id("no");
1899 break;
1900 }
1901
1902 xButton->Show();
1903 m_xDialog->add_button(xButton, nResponse, true);
1904 }
1905
1906 void SalInstanceDialog::set_modal(bool bModal)
1907 {
1908 if (get_modal() == bModal)
1909 return;
1910 m_xDialog->SetModalInputMode(bModal);
1911 }
1912
1913 bool SalInstanceDialog::get_modal() const { return m_xDialog->IsModalInputMode(); }
1914
1915 void SalInstanceDialog::set_default_response(int nResponse)
1916 {
1917 m_xDialog->set_default_response(nResponse);
1918 }
1919
1920 weld::Container* SalInstanceDialog::weld_content_area()
1921 {
1922 return new SalInstanceContainer(m_xDialog->get_content_area(), m_pBuilder, false);
1923 }
1924
1925 IMPL_LINK(SalInstanceDialog, PopupScreenShotMenuHdl, const CommandEvent&, rCEvt, bool)
1926 {
1927 if (CommandEventId::ContextMenu == rCEvt.GetCommand())
1928 {
1929 const Point aMenuPos(rCEvt.GetMousePosPixel());
1930 ScopedVclPtrInstance<PopupMenu> aMenu;
1931 sal_uInt16 nLocalID(1);
1932
1933 aMenu->InsertItem(nLocalID, VclResId(SV_BUTTONTEXT_SCREENSHOT));
1934 aMenu->SetHelpText(nLocalID, VclResId(SV_HELPTEXT_SCREENSHOT));
1935 aMenu->SetHelpId(nLocalID, "InteractiveScreenshotMode");
1936 aMenu->EnableItem(nLocalID);
1937
1938 const sal_uInt16 nId(aMenu->Execute(m_xDialog, aMenuPos));
1939
1940 // 0 == no selection (so not usable as ID)
1941 if (0 != nId)
1942 {
1943 // open screenshot annotation dialog
1944 VclAbstractDialogFactory* pFact = VclAbstractDialogFactory::Create();
1945 VclPtr<AbstractScreenshotAnnotationDlg> pTmp
1946 = pFact->CreateScreenshotAnnotationDlg(*this);
1947 ScopedVclPtr<AbstractScreenshotAnnotationDlg> pDialog(pTmp);
1948
1949 if (pDialog)
1950 {
1951 // currently just execute the dialog, no need to do
1952 // different things for ok/cancel. This may change later,
1953 // for that case use 'if (pDlg->Execute() == RET_OK)'
1954 pDialog->Execute();
1955 }
1956 }
1957
1958 // consume event when:
1959 // - CommandEventId::ContextMenu
1960 // - bScreenshotMode
1961 return true;
1962 }
1963
1964 return false;
1965 }
1966
1967 SalInstanceMessageDialog::SalInstanceMessageDialog(::MessageDialog* pDialog,
1968 SalInstanceBuilder* pBuilder,
1969 bool bTakeOwnership)
1970 : SalInstanceDialog(pDialog, pBuilder, bTakeOwnership)
1971 , m_xMessageDialog(pDialog)
1972 {
1973 }
1974
1975 void SalInstanceMessageDialog::set_primary_text(const OUString& rText)
1976 {
1977 m_xMessageDialog->set_primary_text(rText);
1978 }
1979
1980 OUString SalInstanceMessageDialog::get_primary_text() const
1981 {
1982 return m_xMessageDialog->get_primary_text();
1983 }
1984
1985 void SalInstanceMessageDialog::set_secondary_text(const OUString& rText)
1986 {
1987 m_xMessageDialog->set_secondary_text(rText);
1988 }
1989
1990 OUString SalInstanceMessageDialog::get_secondary_text() const
1991 {
1992 return m_xMessageDialog->get_secondary_text();
1993 }
1994
1995 weld::Container* SalInstanceMessageDialog::weld_message_area()
1996 {
1997 return new SalInstanceContainer(m_xMessageDialog->get_message_area(), m_pBuilder, false);
1998 }
1999
2000 int SalInstanceAssistant::find_page(std::u16string_view rIdent) const
2001 {
2002 for (size_t i = 0; i < m_aAddedPages.size(); ++i)
2003 {
2004 if (m_aAddedPages[i]->get_id() == rIdent)
2005 return i;
2006 }
2007 return -1;
2008 }
2009
2010 int SalInstanceAssistant::find_id(int nId) const
2011 {
2012 for (size_t i = 0; i < m_aIds.size(); ++i)
2013 {
2014 if (nId == m_aIds[i])
2015 return i;
2016 }
2017 return -1;
2018 }
2019
2020 SalInstanceAssistant::SalInstanceAssistant(vcl::RoadmapWizard* pDialog,
2021 SalInstanceBuilder* pBuilder, bool bTakeOwnership)
2022 : SalInstanceDialog(pDialog, pBuilder, bTakeOwnership)
2023 , m_xWizard(pDialog)
2024 , m_aUpdateRoadmapIdle("SalInstanceAssistant m_aUpdateRoadmapIdle")
2025 {
2026 m_xWizard->SetItemSelectHdl(LINK(this, SalInstanceAssistant, OnRoadmapItemSelected));
2027
2028 m_aUpdateRoadmapIdle.SetInvokeHandler(LINK(this, SalInstanceAssistant, UpdateRoadmap_Hdl));
2029 m_aUpdateRoadmapIdle.SetPriority(TaskPriority::HIGHEST);
2030 }
2031
2032 int SalInstanceAssistant::get_current_page() const { return find_id(m_xWizard->GetCurLevel()); }
2033
2034 int SalInstanceAssistant::get_n_pages() const { return m_aAddedPages.size(); }
2035
2036 OUString SalInstanceAssistant::get_page_ident(int nPage) const
2037 {
2038 return m_aAddedPages[nPage]->get_id();
2039 }
2040
2041 OUString SalInstanceAssistant::get_current_page_ident() const
2042 {
2043 return get_page_ident(get_current_page());
2044 }
2045
2046 void SalInstanceAssistant::set_current_page(int nPage)
2047 {
2048 disable_notify_events();
2049
2050 // take the first shown page as the size for all pages
2051 if (m_xWizard->GetPageSizePixel().Width() == 0)
2052 {
2053 Size aFinalSize;
2054 for (int i = 0, nPages = get_n_pages(); i < nPages; ++i)
2055 {
2056 TabPage* pPage = m_xWizard->GetPage(m_aIds[i]);
2057 assert(pPage);
2058 Size aPageSize(pPage->get_preferred_size());
2059 if (aPageSize.Width() > aFinalSize.Width())
2060 aFinalSize.setWidth(aPageSize.Width());
2061 if (aPageSize.Height() > aFinalSize.Height())
2062 aFinalSize.setHeight(aPageSize.Height());
2063 }
2064 m_xWizard->SetPageSizePixel(aFinalSize);
2065 }
2066
2067 (void)m_xWizard->ShowPage(m_aIds[nPage]);
2068 enable_notify_events();
2069 }
2070
2071 void SalInstanceAssistant::set_current_page(const OUString& rIdent)
2072 {
2073 int nIndex = find_page(rIdent);
2074 if (nIndex == -1)
2075 return;
2076 set_current_page(nIndex);
2077 }
2078
2079 void SalInstanceAssistant::set_page_index(const OUString& rIdent, int nNewIndex)
2080 {
2081 int nOldIndex = find_page(rIdent);
2082
2083 if (nOldIndex == -1)
2084 return;
2085
2086 if (nOldIndex == nNewIndex)
2087 return;
2088
2089 disable_notify_events();
2090
2091 auto entry = std::move(m_aAddedPages[nOldIndex]);
2092 m_aAddedPages.erase(m_aAddedPages.begin() + nOldIndex);
2093 m_aAddedPages.insert(m_aAddedPages.begin() + nNewIndex, std::move(entry));
2094
2095 int nId = m_aIds[nOldIndex];
2096 m_aIds.erase(m_aIds.begin() + nOldIndex);
2097 m_aIds.insert(m_aIds.begin() + nNewIndex, nId);
2098
2099 m_aUpdateRoadmapIdle.Start();
2100
2101 enable_notify_events();
2102 }
2103
2104 weld::Container* SalInstanceAssistant::append_page(const OUString& rIdent)
2105 {
2106 VclPtrInstance<TabPage> xPage(m_xWizard);
2107 VclPtrInstance<VclGrid> xGrid(xPage);
2108 xPage->set_id(rIdent);
2109 xPage->Show();
2110 xGrid->set_hexpand(true);
2111 xGrid->set_vexpand(true);
2112 xGrid->Show();
2113 m_xWizard->AddPage(xPage);
2114 m_aIds.push_back(m_aAddedPages.size());
2115 m_xWizard->SetPage(m_aIds.back(), xPage);
2116 m_aAddedPages.push_back(xPage);
2117 m_aAddedGrids.push_back(xGrid);
2118
2119 m_aUpdateRoadmapIdle.Start();
2120
2121 m_aPages.emplace_back(new SalInstanceContainer(xGrid, m_pBuilder, false));
2122 return m_aPages.back().get();
2123 }
2124
2125 OUString SalInstanceAssistant::get_page_title(const OUString& rIdent) const
2126 {
2127 int nIndex = find_page(rIdent);
2128 if (nIndex == -1)
2129 return OUString();
2130 return m_aAddedPages[nIndex]->GetText();
2131 }
2132
2133 void SalInstanceAssistant::set_page_title(const OUString& rIdent, const OUString& rTitle)
2134 {
2135 int nIndex = find_page(rIdent);
2136 if (nIndex == -1)
2137 return;
2138 if (m_aAddedPages[nIndex]->GetText() != rTitle)
2139 {
2140 disable_notify_events();
2141 m_aAddedPages[nIndex]->SetText(rTitle);
2142 m_aUpdateRoadmapIdle.Start();
2143 enable_notify_events();
2144 }
2145 }
2146
2147 void SalInstanceAssistant::set_page_sensitive(const OUString& rIdent, bool bSensitive)
2148 {
2149 int nIndex = find_page(rIdent);
2150 if (nIndex == -1)
2151 return;
2152 if (m_aAddedPages[nIndex]->IsEnabled() != bSensitive)
2153 {
2154 disable_notify_events();
2155 m_aAddedPages[nIndex]->Enable(bSensitive);
2156 m_aUpdateRoadmapIdle.Start();
2157 enable_notify_events();
2158 }
2159 }
2160
2161 void SalInstanceAssistant::set_page_side_help_id(const OUString& rHelpId)
2162 {
2163 m_xWizard->SetRoadmapHelpId(rHelpId);
2164 }
2165
2166 void SalInstanceAssistant::set_page_side_image(const OUString& rImage)
2167 {
2168 m_xWizard->SetRoadmapBitmap(createImage(rImage).GetBitmapEx());
2169 }
2170
2171 SalInstanceAssistant::~SalInstanceAssistant()
2172 {
2173 for (auto& rGrid : m_aAddedGrids)
2174 rGrid.disposeAndClear();
2175 for (auto& rPage : m_aAddedPages)
2176 rPage.disposeAndClear();
2177 }
2178
2179 IMPL_LINK_NOARG(SalInstanceAssistant, OnRoadmapItemSelected, LinkParamNone*, void)
2180 {
2181 if (notify_events_disabled())
2182 return;
2183 auto nCurItemId = m_xWizard->GetCurrentRoadmapItemID();
2184 int nPageIndex(find_id(nCurItemId));
2185 if (!signal_jump_page(get_page_ident(nPageIndex)) && nCurItemId != m_xWizard->GetCurLevel())
2186 m_xWizard->SelectRoadmapItemByID(m_xWizard->GetCurLevel());
2187 }
2188
2189 IMPL_LINK_NOARG(SalInstanceAssistant, UpdateRoadmap_Hdl, Timer*, void)
2190 {
2191 disable_notify_events();
2192
2193 m_xWizard->DeleteRoadmapItems();
2194
2195 int nPos = 0;
2196 for (size_t i = 0; i < m_aAddedPages.size(); ++i)
2197 {
2198 const OUString& rLabel = m_aAddedPages[i]->GetText();
2199 bool bSensitive = m_aAddedPages[i]->IsEnabled();
2200 if (rLabel.isEmpty())
2201 continue;
2202 m_xWizard->InsertRoadmapItem(nPos++, rLabel, m_aIds[i], bSensitive);
2203 }
2204
2205 m_xWizard->SelectRoadmapItemByID(m_aIds[get_current_page()], false);
2206
2207 m_xWizard->ShowRoadmap(nPos != 0);
2208
2209 enable_notify_events();
2210 }
2211
2212 SalInstanceFrame::SalInstanceFrame(VclFrame* pFrame, SalInstanceBuilder* pBuilder,
2213 bool bTakeOwnership)
2214 : SalInstanceContainer(pFrame, pBuilder, bTakeOwnership)
2215 , m_xFrame(pFrame)
2216 {
2217 }
2218
2219 void SalInstanceFrame::set_label(const OUString& rText) { m_xFrame->set_label(rText); }
2220
2221 OUString SalInstanceFrame::get_label() const { return m_xFrame->get_label(); }
2222
2223 namespace
2224 {
2225 class SalInstancePaned : public SalInstanceContainer, public virtual weld::Paned
2226 {
2227 private:
2228 VclPtr<VclPaned> m_xPaned;
2229
2230 public:
2231 SalInstancePaned(VclPaned* pPaned, SalInstanceBuilder* pBuilder, bool bTakeOwnership)
2232 : SalInstanceContainer(pPaned, pBuilder, bTakeOwnership)
2233 , m_xPaned(pPaned)
2234 {
2235 }
2236
2237 virtual void set_position(int nPos) override { m_xPaned->set_position(nPos); }
2238
2239 virtual int get_position() const override { return m_xPaned->get_position(); }
2240 };
2241 }
2242
2243 void SalInstanceScrolledWindow::customize_scrollbars(ScrollBar& rScrollBar,
2244 const Color& rButtonTextColor,
2245 const Color& rBackgroundColor,
2246 const Color& rShadowColor,
2247 const Color& rFaceColor)
2248 {
2249 rScrollBar.EnableNativeWidget(false);
2250 AllSettings aSettings = rScrollBar.GetSettings();
2251 StyleSettings aStyleSettings = aSettings.GetStyleSettings();
2252 aStyleSettings.SetButtonTextColor(rButtonTextColor);
2253 aStyleSettings.SetCheckedColor(rBackgroundColor); // background
2254 aStyleSettings.SetShadowColor(rShadowColor);
2255 aStyleSettings.SetFaceColor(rFaceColor);
2256 aSettings.SetStyleSettings(aStyleSettings);
2257 rScrollBar.SetSettings(aSettings);
2258 }
2259
2260 SalInstanceScrolledWindow::SalInstanceScrolledWindow(VclScrolledWindow* pScrolledWindow,
2261 SalInstanceBuilder* pBuilder,
2262 bool bTakeOwnership,
2263 bool bUserManagedScrolling)
2264 : SalInstanceContainer(pScrolledWindow, pBuilder, bTakeOwnership)
2265 , m_xScrolledWindow(pScrolledWindow)
2266 , m_bUserManagedScrolling(bUserManagedScrolling)
2267 {
2268 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2269 m_aOrigVScrollHdl = rVertScrollBar.GetScrollHdl();
2270 rVertScrollBar.SetScrollHdl(LINK(this, SalInstanceScrolledWindow, VscrollHdl));
2271 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2272 m_aOrigHScrollHdl = rHorzScrollBar.GetScrollHdl();
2273 rHorzScrollBar.SetScrollHdl(LINK(this, SalInstanceScrolledWindow, HscrollHdl));
2274 m_xScrolledWindow->setUserManagedScrolling(m_bUserManagedScrolling);
2275 }
2276
2277 void SalInstanceScrolledWindow::hadjustment_configure(int value, int lower, int upper,
2278 int step_increment, int page_increment,
2279 int page_size)
2280 {
2281 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2282 rHorzScrollBar.SetRangeMin(lower);
2283 rHorzScrollBar.SetRangeMax(upper);
2284 rHorzScrollBar.SetLineSize(step_increment);
2285 rHorzScrollBar.SetPageSize(page_increment);
2286 rHorzScrollBar.SetThumbPos(value);
2287 rHorzScrollBar.SetVisibleSize(page_size);
2288 }
2289
2290 int SalInstanceScrolledWindow::hadjustment_get_value() const
2291 {
2292 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2293 return rHorzScrollBar.GetThumbPos();
2294 }
2295
2296 void SalInstanceScrolledWindow::hadjustment_set_value(int value)
2297 {
2298 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2299 rHorzScrollBar.SetThumbPos(value);
2300 if (!m_bUserManagedScrolling)
2301 m_aOrigHScrollHdl.Call(&rHorzScrollBar);
2302 }
2303
2304 int SalInstanceScrolledWindow::hadjustment_get_upper() const
2305 {
2306 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2307 return rHorzScrollBar.GetRangeMax();
2308 }
2309
2310 void SalInstanceScrolledWindow::hadjustment_set_upper(int upper)
2311 {
2312 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2313 rHorzScrollBar.SetRangeMax(upper);
2314 }
2315
2316 int SalInstanceScrolledWindow::hadjustment_get_page_size() const
2317 {
2318 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2319 return rHorzScrollBar.GetVisibleSize();
2320 }
2321
2322 void SalInstanceScrolledWindow::hadjustment_set_page_size(int size)
2323 {
2324 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2325 return rHorzScrollBar.SetVisibleSize(size);
2326 }
2327
2328 void SalInstanceScrolledWindow::hadjustment_set_page_increment(int size)
2329 {
2330 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2331 return rHorzScrollBar.SetPageSize(size);
2332 }
2333
2334 void SalInstanceScrolledWindow::hadjustment_set_step_increment(int size)
2335 {
2336 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2337 return rHorzScrollBar.SetLineSize(size);
2338 }
2339
2340 void SalInstanceScrolledWindow::set_hpolicy(VclPolicyType eHPolicy)
2341 {
2342 WinBits nWinBits = m_xScrolledWindow->GetStyle() & ~(WB_AUTOHSCROLL | WB_HSCROLL);
2343 if (eHPolicy == VclPolicyType::ALWAYS)
2344 nWinBits |= WB_HSCROLL;
2345 else if (eHPolicy == VclPolicyType::AUTOMATIC)
2346 nWinBits |= WB_AUTOHSCROLL;
2347 m_xScrolledWindow->SetStyle(nWinBits);
2348 m_xScrolledWindow->queue_resize();
2349 }
2350
2351 VclPolicyType SalInstanceScrolledWindow::get_hpolicy() const
2352 {
2353 WinBits nWinBits = m_xScrolledWindow->GetStyle();
2354 if (nWinBits & WB_AUTOHSCROLL)
2355 return VclPolicyType::AUTOMATIC;
2356 else if (nWinBits & WB_HSCROLL)
2357 return VclPolicyType::ALWAYS;
2358 return VclPolicyType::NEVER;
2359 }
2360
2361 void SalInstanceScrolledWindow::vadjustment_configure(int value, int lower, int upper,
2362 int step_increment, int page_increment,
2363 int page_size)
2364 {
2365 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2366 rVertScrollBar.SetRangeMin(lower);
2367 rVertScrollBar.SetRangeMax(upper);
2368 rVertScrollBar.SetLineSize(step_increment);
2369 rVertScrollBar.SetPageSize(page_increment);
2370 rVertScrollBar.SetThumbPos(value);
2371 rVertScrollBar.SetVisibleSize(page_size);
2372 }
2373
2374 int SalInstanceScrolledWindow::vadjustment_get_value() const
2375 {
2376 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2377 return rVertScrollBar.GetThumbPos();
2378 }
2379
2380 void SalInstanceScrolledWindow::vadjustment_set_value(int value)
2381 {
2382 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2383 rVertScrollBar.SetThumbPos(value);
2384 if (!m_bUserManagedScrolling)
2385 m_aOrigVScrollHdl.Call(&rVertScrollBar);
2386 }
2387
2388 int SalInstanceScrolledWindow::vadjustment_get_upper() const
2389 {
2390 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2391 return rVertScrollBar.GetRangeMax();
2392 }
2393
2394 void SalInstanceScrolledWindow::vadjustment_set_upper(int upper)
2395 {
2396 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2397 rVertScrollBar.SetRangeMax(upper);
2398 }
2399
2400 int SalInstanceScrolledWindow::vadjustment_get_lower() const
2401 {
2402 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2403 return rVertScrollBar.GetRangeMin();
2404 }
2405
2406 void SalInstanceScrolledWindow::vadjustment_set_lower(int lower)
2407 {
2408 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2409 rVertScrollBar.SetRangeMin(lower);
2410 }
2411
2412 int SalInstanceScrolledWindow::vadjustment_get_page_size() const
2413 {
2414 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2415 return rVertScrollBar.GetVisibleSize();
2416 }
2417
2418 void SalInstanceScrolledWindow::vadjustment_set_page_size(int size)
2419 {
2420 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2421 return rVertScrollBar.SetVisibleSize(size);
2422 }
2423
2424 void SalInstanceScrolledWindow::vadjustment_set_page_increment(int size)
2425 {
2426 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2427 return rVertScrollBar.SetPageSize(size);
2428 }
2429
2430 void SalInstanceScrolledWindow::vadjustment_set_step_increment(int size)
2431 {
2432 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2433 return rVertScrollBar.SetLineSize(size);
2434 }
2435
2436 void SalInstanceScrolledWindow::set_vpolicy(VclPolicyType eVPolicy)
2437 {
2438 WinBits nWinBits = m_xScrolledWindow->GetStyle() & ~(WB_AUTOVSCROLL | WB_VSCROLL);
2439 if (eVPolicy == VclPolicyType::ALWAYS)
2440 nWinBits |= WB_VSCROLL;
2441 else if (eVPolicy == VclPolicyType::AUTOMATIC)
2442 nWinBits |= WB_AUTOVSCROLL;
2443 m_xScrolledWindow->SetStyle(nWinBits);
2444 m_xScrolledWindow->queue_resize();
2445 }
2446
2447 VclPolicyType SalInstanceScrolledWindow::get_vpolicy() const
2448 {
2449 WinBits nWinBits = m_xScrolledWindow->GetStyle();
2450 if (nWinBits & WB_AUTOVSCROLL)
2451 return VclPolicyType::AUTOMATIC;
2452 else if (nWinBits & WB_VSCROLL)
2453 return VclPolicyType::ALWAYS;
2454 return VclPolicyType::NEVER;
2455 }
2456
2457 int SalInstanceScrolledWindow::get_scroll_thickness() const
2458 {
2459 return m_xScrolledWindow->getVertScrollBar().get_preferred_size().Width();
2460 }
2461
2462 void SalInstanceScrolledWindow::set_scroll_thickness(int nThickness)
2463 {
2464 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2465 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2466 rHorzScrollBar.set_height_request(nThickness);
2467 rVertScrollBar.set_width_request(nThickness);
2468 }
2469
2470 void SalInstanceScrolledWindow::customize_scrollbars(const Color& rBackgroundColor,
2471 const Color& rShadowColor,
2472 const Color& rFaceColor)
2473 {
2474 ScrollBar& rHorzScrollBar = m_xScrolledWindow->getHorzScrollBar();
2475 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2476 customize_scrollbars(rHorzScrollBar, Color(0, 0, 0), rBackgroundColor, rShadowColor,
2477 rFaceColor);
2478 customize_scrollbars(rVertScrollBar, Color(0, 0, 0), rBackgroundColor, rShadowColor,
2479 rFaceColor);
2480 }
2481
2482 SalInstanceScrolledWindow::~SalInstanceScrolledWindow()
2483 {
2484 ScrollBar& rVertScrollBar = m_xScrolledWindow->getVertScrollBar();
2485 rVertScrollBar.SetScrollHdl(m_aOrigVScrollHdl);
2486 }
2487
2488 IMPL_LINK(SalInstanceScrolledWindow, VscrollHdl, ScrollBar*, pScrollBar, void)
2489 {
2490 signal_vadjustment_changed();
2491 if (!m_bUserManagedScrolling)
2492 m_aOrigVScrollHdl.Call(pScrollBar);
2493 }
2494
2495 IMPL_LINK_NOARG(SalInstanceScrolledWindow, HscrollHdl, ScrollBar*, void)
2496 {
2497 signal_hadjustment_changed();
2498 if (!m_bUserManagedScrolling)
2499 m_aOrigHScrollHdl.Call(&m_xScrolledWindow->getHorzScrollBar());
2500 }
2501
2502 namespace
2503 {
2504 class SalInstanceScrollbar : public SalInstanceWidget, public virtual weld::Scrollbar
2505 {
2506 private:
2507 VclPtr<ScrollBar> m_xScrollBar;
2508
2509 DECL_LINK(ScrollHdl, ScrollBar*, void);
2510
2511 public:
2512 SalInstanceScrollbar(ScrollBar* pScrollbar, SalInstanceBuilder* pBuilder, bool bTakeOwnership)
2513 : SalInstanceWidget(pScrollbar, pBuilder, bTakeOwnership)
2514 , m_xScrollBar(pScrollbar)
2515 {
2516 m_xScrollBar->SetScrollHdl(LINK(this, SalInstanceScrollbar, ScrollHdl));
2517 m_xScrollBar->EnableDrag();
2518 }
2519
2520 virtual void adjustment_configure(int value, int lower, int upper, int step_increment,
2521 int page_increment, int page_size) override
2522 {
2523 m_xScrollBar->SetRangeMin(lower);
2524 m_xScrollBar->SetRangeMax(upper);
2525 m_xScrollBar->SetLineSize(step_increment);
2526 m_xScrollBar->SetPageSize(page_increment);
2527 m_xScrollBar->SetThumbPos(value);
2528 m_xScrollBar->SetVisibleSize(page_size);
2529 }
2530
2531 virtual int adjustment_get_value() const override { return m_xScrollBar->GetThumbPos(); }
2532
2533 virtual void adjustment_set_value(int value) override { m_xScrollBar->SetThumbPos(value); }
2534
2535 virtual int adjustment_get_upper() const override { return m_xScrollBar->GetRangeMax(); }
2536
2537 virtual void adjustment_set_upper(int upper) override { m_xScrollBar->SetRangeMax(upper); }
2538
2539 virtual int adjustment_get_lower() const override { return m_xScrollBar->GetRangeMin(); }
2540
2541 virtual void adjustment_set_lower(int lower) override { m_xScrollBar->SetRangeMin(lower); }
2542
2543 virtual int adjustment_get_page_size() const override { return m_xScrollBar->GetVisibleSize(); }
2544
2545 virtual void adjustment_set_page_size(int size) override { m_xScrollBar->SetVisibleSize(size); }
2546
2547 virtual int adjustment_get_page_increment() const override
2548 {
2549 return m_xScrollBar->GetPageSize();
2550 }
2551
2552 virtual void adjustment_set_page_increment(int size) override
2553 {
2554 m_xScrollBar->SetPageSize(size);
2555 }
2556
2557 virtual int adjustment_get_step_increment() const override
2558 {
2559 return m_xScrollBar->GetLineSize();
2560 }
2561
2562 virtual void adjustment_set_step_increment(int size) override
2563 {
2564 m_xScrollBar->SetLineSize(size);
2565 }
2566
2567 virtual ScrollType get_scroll_type() const override { return m_xScrollBar->GetType(); }
2568
2569 virtual int get_scroll_thickness() const override
2570 {
2571 if (m_xScrollBar->GetStyle() & WB_HORZ)
2572 return m_xScrollBar->get_preferred_size().Height();
2573 return m_xScrollBar->get_preferred_size().Width();
2574 }
2575
2576 virtual void set_scroll_thickness(int nThickness) override
2577 {
2578 if (m_xScrollBar->GetStyle() & WB_HORZ)
2579 m_xScrollBar->set_height_request(nThickness);
2580 else
2581 m_xScrollBar->set_width_request(nThickness);
2582 }
2583 };
2584 }
2585
2586 IMPL_LINK_NOARG(SalInstanceScrollbar, ScrollHdl, ScrollBar*, void) { signal_adjustment_changed(); }
2587
2588 SalInstanceNotebook::SalInstanceNotebook(TabControl* pNotebook, SalInstanceBuilder* pBuilder,
2589 bool bTakeOwnership)
2590 : SalInstanceWidget(pNotebook, pBuilder, bTakeOwnership)
2591 , m_xNotebook(pNotebook)
2592 {
2593 m_xNotebook->SetActivatePageHdl(LINK(this, SalInstanceNotebook, ActivatePageHdl));
2594 m_xNotebook->SetDeactivatePageHdl(LINK(this, SalInstanceNotebook, DeactivatePageHdl));
2595 }
2596
2597 int SalInstanceNotebook::get_current_page() const
2598 {
2599 return m_xNotebook->GetPagePos(m_xNotebook->GetCurPageId());
2600 }
2601
2602 OUString SalInstanceNotebook::get_page_ident(int nPage) const
2603 {
2604 return m_xNotebook->GetPageName(m_xNotebook->GetPageId(nPage));
2605 }
2606
2607 OUString SalInstanceNotebook::get_current_page_ident() const
2608 {
2609 return m_xNotebook->GetPageName(m_xNotebook->GetCurPageId());
2610 }
2611
2612 int SalInstanceNotebook::get_page_index(const OUString& rIdent) const
2613 {
2614 sal_uInt16 nPageId = m_xNotebook->GetPageId(rIdent);
2615 sal_uInt16 nPageIndex = m_xNotebook->GetPagePos(nPageId);
2616 if (nPageIndex == TAB_PAGE_NOTFOUND)
2617 return -1;
2618 return nPageIndex;
2619 }
2620
2621 weld::Container* SalInstanceNotebook::get_page(const OUString& rIdent) const
2622 {
2623 int nPageIndex = get_page_index(rIdent);
2624 if (nPageIndex == -1)
2625 return nullptr;
2626 sal_uInt16 nPageId = m_xNotebook->GetPageId(rIdent);
2627 TabPage* pPage = m_xNotebook->GetTabPage(nPageId);
2628 vcl::Window* pChild = pPage->GetChild(0);
2629 if (m_aPages.size() < nPageIndex + 1U)
2630 m_aPages.resize(nPageIndex + 1U);
2631 if (!m_aPages[nPageIndex])
2632 m_aPages[nPageIndex] = std::make_shared<SalInstanceContainer>(pChild, m_pBuilder, false);
2633 return m_aPages[nPageIndex].get();
2634 }
2635
2636 void SalInstanceNotebook::set_current_page(int nPage)
2637 {
2638 m_xNotebook->SetCurPageId(m_xNotebook->GetPageId(nPage));
2639 }
2640
2641 void SalInstanceNotebook::set_current_page(const OUString& rIdent)
2642 {
2643 m_xNotebook->SetCurPageId(m_xNotebook->GetPageId(rIdent));
2644 }
2645
2646 void SalInstanceNotebook::remove_page(const OUString& rIdent)
2647 {
2648 sal_uInt16 nPageId = m_xNotebook->GetPageId(rIdent);
2649 sal_uInt16 nPageIndex = m_xNotebook->GetPagePos(nPageId);
2650 if (nPageIndex == TAB_PAGE_NOTFOUND)
2651 return;
2652
2653 m_xNotebook->RemovePage(nPageId);
2654 if (nPageIndex < m_aPages.size())
2655 m_aPages.erase(m_aPages.begin() + nPageIndex);
2656
2657 auto iter = m_aAddedPages.find(rIdent);
2658 if (iter != m_aAddedPages.end())
2659 {
2660 iter->second.second.disposeAndClear();
2661 iter->second.first.disposeAndClear();
2662 m_aAddedPages.erase(iter);
2663 }
2664 }
2665
2666 void SalInstanceNotebook::insert_page(const OUString& rIdent, const OUString& rLabel, int nPos)
2667 {
2668 sal_uInt16 nPageCount = m_xNotebook->GetPageCount();
2669 sal_uInt16 nLastPageId = nPageCount ? m_xNotebook->GetPageId(nPageCount - 1) : 0;
2670 sal_uInt16 nNewPageId = nLastPageId + 1;
2671 while (m_xNotebook->GetPagePos(nNewPageId) != TAB_PAGE_NOTFOUND)
2672 ++nNewPageId;
2673 m_xNotebook->InsertPage(nNewPageId, rLabel, nPos == -1 ? TAB_APPEND : nPos);
2674 VclPtrInstance<TabPage> xPage(m_xNotebook);
2675 VclPtrInstance<VclGrid> xGrid(xPage);
2676 xPage->Show();
2677 xGrid->set_hexpand(true);
2678 xGrid->set_vexpand(true);
2679 xGrid->Show();
2680 m_xNotebook->SetTabPage(nNewPageId, xPage);
2681 m_xNotebook->SetPageName(nNewPageId, rIdent);
2682 m_aAddedPages.try_emplace(rIdent, xPage, xGrid);
2683
2684 if (nPos != -1)
2685 {
2686 unsigned int nPageIndex = static_cast<unsigned int>(nPos);
2687 if (nPageIndex < m_aPages.size())
2688 m_aPages.insert(m_aPages.begin() + nPageIndex, nullptr);
2689 }
2690 }
2691
2692 int SalInstanceNotebook::get_n_pages() const { return m_xNotebook->GetPageCount(); }
2693
2694 OUString SalInstanceNotebook::get_tab_label_text(const OUString& rIdent) const
2695 {
2696 return m_xNotebook->GetPageText(m_xNotebook->GetPageId(rIdent));
2697 }
2698
2699 void SalInstanceNotebook::set_tab_label_text(const OUString& rIdent, const OUString& rText)
2700 {
2701 return m_xNotebook->SetPageText(m_xNotebook->GetPageId(rIdent), rText);
2702 }
2703
2704 void SalInstanceNotebook::set_show_tabs(bool bShow)
2705 {
2706 m_xNotebook->set_property("show-tabs", OUString::boolean(bShow));
2707 }
2708
2709 SalInstanceNotebook::~SalInstanceNotebook()
2710 {
2711 for (auto& rItem : m_aAddedPages)
2712 {
2713 rItem.second.second.disposeAndClear();
2714 rItem.second.first.disposeAndClear();
2715 }
2716 m_xNotebook->SetActivatePageHdl(Link<TabControl*, void>());
2717 m_xNotebook->SetDeactivatePageHdl(Link<TabControl*, bool>());
2718 }
2719
2720 IMPL_LINK_NOARG(SalInstanceNotebook, DeactivatePageHdl, TabControl*, bool)
2721 {
2722 return !m_aLeavePageHdl.IsSet() || m_aLeavePageHdl.Call(get_current_page_ident());
2723 }
2724
2725 IMPL_LINK_NOARG(SalInstanceNotebook, ActivatePageHdl, TabControl*, void)
2726 {
2727 m_aEnterPageHdl.Call(get_current_page_ident());
2728 }
2729
2730 namespace
2731 {
2732 class SalInstanceVerticalNotebook : public SalInstanceWidget, public virtual weld::Notebook
2733 {
2734 private:
2735 VclPtr<VerticalTabControl> m_xNotebook;
2736 mutable std::vector<std::unique_ptr<SalInstanceContainer>> m_aPages;
2737
2738 DECL_LINK(DeactivatePageHdl, VerticalTabControl*, bool);
2739 DECL_LINK(ActivatePageHdl, VerticalTabControl*, void);
2740
2741 public:
2742 SalInstanceVerticalNotebook(VerticalTabControl* pNotebook, SalInstanceBuilder* pBuilder,
2743 bool bTakeOwnership)
2744 : SalInstanceWidget(pNotebook, pBuilder, bTakeOwnership)
2745 , m_xNotebook(pNotebook)
2746 {
2747 m_xNotebook->SetActivatePageHdl(LINK(this, SalInstanceVerticalNotebook, ActivatePageHdl));
2748 m_xNotebook->SetDeactivatePageHdl(
2749 LINK(this, SalInstanceVerticalNotebook, DeactivatePageHdl));
2750 }
2751
2752 virtual int get_current_page() const override
2753 {
2754 return m_xNotebook->GetPagePos(m_xNotebook->GetCurPageId());
2755 }
2756
2757 virtual OUString get_page_ident(int nPage) const override
2758 {
2759 return m_xNotebook->GetPageId(nPage);
2760 }
2761
2762 virtual OUString get_current_page_ident() const override { return m_xNotebook->GetCurPageId(); }
2763
2764 virtual int get_page_index(const OUString& rIdent) const override
2765 {
2766 sal_uInt16 nPageIndex = m_xNotebook->GetPagePos(rIdent);
2767 if (nPageIndex == TAB_PAGE_NOTFOUND)
2768 return -1;
2769 return nPageIndex;
2770 }
2771
2772 virtual weld::Container* get_page(const OUString& rIdent) const override
2773 {
2774 int nPageIndex = get_page_index(rIdent);
2775 if (nPageIndex == -1)
2776 return nullptr;
2777 auto pChild = m_xNotebook->GetPage(rIdent);
2778 if (m_aPages.size() < nPageIndex + 1U)
2779 m_aPages.resize(nPageIndex + 1U);
2780 if (!m_aPages[nPageIndex])
2781 m_aPages[nPageIndex].reset(new SalInstanceContainer(pChild, m_pBuilder, false));
2782 return m_aPages[nPageIndex].get();
2783 }
2784
2785 virtual void set_current_page(int nPage) override
2786 {
2787 m_xNotebook->SetCurPageId(m_xNotebook->GetPageId(nPage));
2788 }
2789
2790 virtual void set_current_page(const OUString& rIdent) override
2791 {
2792 m_xNotebook->SetCurPageId(rIdent);
2793 }
2794
2795 virtual void remove_page(const OUString& rIdent) override
2796 {
2797 sal_uInt16 nPageIndex = m_xNotebook->GetPagePos(rIdent);
2798 if (nPageIndex == TAB_PAGE_NOTFOUND)
2799 return;
2800 m_xNotebook->RemovePage(rIdent);
2801 if (nPageIndex < m_aPages.size())
2802 m_aPages.erase(m_aPages.begin() + nPageIndex);
2803 }
2804
2805 virtual void insert_page(const OUString& rIdent, const OUString& rLabel, int nPos) override
2806 {
2807 VclPtrInstance<VclGrid> xGrid(m_xNotebook->GetPageParent());
2808 xGrid->set_hexpand(true);
2809 xGrid->set_vexpand(true);
2810 m_xNotebook->InsertPage(rIdent, rLabel, Image(), "", xGrid, nPos);
2811
2812 if (nPos != -1)
2813 {
2814 unsigned int nPageIndex = static_cast<unsigned int>(nPos);
2815 if (nPageIndex < m_aPages.size())
2816 m_aPages.insert(m_aPages.begin() + nPageIndex, nullptr);
2817 }
2818 }
2819
2820 virtual int get_n_pages() const override { return m_xNotebook->GetPageCount(); }
2821
2822 virtual void set_tab_label_text(const OUString& rIdent, const OUString& rText) override
2823 {
2824 return m_xNotebook->SetPageText(rIdent, rText);
2825 }
2826
2827 virtual OUString get_tab_label_text(const OUString& rIdent) const override
2828 {
2829 return m_xNotebook->GetPageText(rIdent);
2830 }
2831
2832 virtual void set_show_tabs(bool /*bShow*/) override
2833 {
2834 // if someone needs this they will have to implement it in VerticalTabControl
2835 assert(false && "not implemented");
2836 }
2837
2838 virtual ~SalInstanceVerticalNotebook() override
2839 {
2840 m_xNotebook->SetActivatePageHdl(Link<VerticalTabControl*, void>());
2841 m_xNotebook->SetDeactivatePageHdl(Link<VerticalTabControl*, bool>());
2842 }
2843 };
2844 }
2845
2846 IMPL_LINK_NOARG(SalInstanceVerticalNotebook, DeactivatePageHdl, VerticalTabControl*, bool)
2847 {
2848 return !m_aLeavePageHdl.IsSet() || m_aLeavePageHdl.Call(get_current_page_ident());
2849 }
2850
2851 IMPL_LINK_NOARG(SalInstanceVerticalNotebook, ActivatePageHdl, VerticalTabControl*, void)
2852 {
2853 m_aEnterPageHdl.Call(get_current_page_ident());
2854 }
2855
2856 SalInstanceButton::SalInstanceButton(::Button* pButton, SalInstanceBuilder* pBuilder,
2857 bool bTakeOwnership)
2858 : SalInstanceWidget(pButton, pBuilder, bTakeOwnership)
2859 , m_xButton(pButton)
2860 , m_aOldClickHdl(pButton->GetClickHdl())
2861 {
2862 m_xButton->SetClickHdl(LINK(this, SalInstanceButton, ClickHdl));
2863 }
2864
2865 void SalInstanceButton::set_label(const OUString& rText) { m_xButton->SetText(rText); }
2866
2867 void SalInstanceButton::set_image(VirtualDevice* pDevice)
2868 {
2869 m_xButton->SetImageAlign(ImageAlign::Left);
2870 if (pDevice)
2871 m_xButton->SetModeImage(createImage(*pDevice));
2872 else
2873 m_xButton->SetModeImage(Image());
2874 }
2875
2876 void SalInstanceButton::set_image(const css::uno::Reference<css::graphic::XGraphic>& rImage)
2877 {
2878 m_xButton->SetImageAlign(ImageAlign::Left);
2879 m_xButton->SetModeImage(Image(rImage));
2880 }
2881
2882 void SalInstanceButton::set_from_icon_name(const OUString& rIconName)
2883 {
2884 m_xButton->SetModeImage(Image(StockImage::Yes, rIconName));
2885 }
2886
2887 static void set_label_wrap(Control& rWidget, bool wrap)
2888 {
2889 WinBits nBits = rWidget.GetStyle();
2890 nBits &= ~WB_WORDBREAK;
2891 if (wrap)
2892 nBits |= WB_WORDBREAK;
2893 rWidget.SetStyle(nBits);
2894 rWidget.queue_resize();
2895 }
2896
2897 void SalInstanceButton::set_font(const vcl::Font& rFont)
2898 {
2899 m_xButton->SetControlFont(rFont);
2900 m_xButton->Invalidate();
2901 }
2902
2903 void SalInstanceButton::set_custom_button(VirtualDevice* pDevice)
2904 {
2905 if (pDevice)
2906 m_xButton->SetCustomButtonImage(createImage(*pDevice));
2907 else
2908 m_xButton->SetCustomButtonImage(Image());
2909 m_xButton->Invalidate();
2910 }
2911
2912 OUString SalInstanceButton::get_label() const { return m_xButton->GetText(); }
2913
2914 SalInstanceButton::~SalInstanceButton() { m_xButton->SetClickHdl(Link<::Button*, void>()); }
2915
2916 IMPL_LINK(SalInstanceButton, ClickHdl, ::Button*, pButton, void)
2917 {
2918 //if there's no handler set, disengage our intercept and
2919 //run the click again to get default behaviour for cancel/ok
2920 //etc buttons.
2921 if (!m_aClickHdl.IsSet())
2922 {
2923 pButton->SetClickHdl(m_aOldClickHdl);
2924 pButton->Click();
2925 pButton->SetClickHdl(LINK(this, SalInstanceButton, ClickHdl));
2926 return;
2927 }
2928 signal_clicked();
2929 }
2930
2931 weld::Button* SalInstanceDialog::weld_widget_for_response(int nResponse)
2932 {
2933 PushButton* pButton = dynamic_cast<PushButton*>(m_xDialog->get_widget_for_response(nResponse));
2934 return pButton ? new SalInstanceButton(pButton, nullptr, false) : nullptr;
2935 }
2936
2937 weld::Button* SalInstanceAssistant::weld_widget_for_response(int nResponse)
2938 {
2939 PushButton* pButton = nullptr;
2940 if (nResponse == RET_YES)
2941 pButton = m_xWizard->m_pNextPage;
2942 else if (nResponse == RET_NO)
2943 pButton = m_xWizard->m_pPrevPage;
2944 else if (nResponse == RET_OK)
2945 pButton = m_xWizard->m_pFinish;
2946 else if (nResponse == RET_CANCEL)
2947 pButton = m_xWizard->m_pCancel;
2948 else if (nResponse == RET_HELP)
2949 pButton = m_xWizard->m_pHelp;
2950 if (pButton)
2951 return new SalInstanceButton(pButton, nullptr, false);
2952 return nullptr;
2953 }
2954
2955 SalInstanceMenuButton::SalInstanceMenuButton(::MenuButton* pButton, SalInstanceBuilder* pBuilder,
2956 bool bTakeOwnership)
2957 : SalInstanceButton(pButton, pBuilder, bTakeOwnership)
2958 , m_xMenuButton(pButton)
2959 , m_nLastId(0)
2960 {
2961 m_xMenuButton->SetActivateHdl(LINK(this, SalInstanceMenuButton, ActivateHdl));
2962 m_xMenuButton->SetSelectHdl(LINK(this, SalInstanceMenuButton, MenuSelectHdl));
2963 if (PopupMenu* pMenu = m_xMenuButton->GetPopupMenu())
2964 {
2965 pMenu->SetMenuFlags(MenuFlags::NoAutoMnemonics);
2966 const auto nCount = pMenu->GetItemCount();
2967 m_nLastId = nCount ? pMenu->GetItemId(nCount - 1) : 0;
2968 }
2969 }
2970
2971 void SalInstanceMenuButton::set_active(bool active)
2972 {
2973 if (active == get_active())
2974 return;
2975 if (active)
2976 m_xMenuButton->ExecuteMenu();
2977 else
2978 m_xMenuButton->CancelMenu();
2979 }
2980
2981 bool SalInstanceMenuButton::get_active() const { return m_xMenuButton->InPopupMode(); }
2982
2983 void SalInstanceMenuButton::set_inconsistent(bool /*inconsistent*/)
2984 {
2985 //not available
2986 }
2987
2988 bool SalInstanceMenuButton::get_inconsistent() const { return false; }
2989
2990 void SalInstanceMenuButton::insert_item(int pos, const OUString& rId, const OUString& rStr,
2991 const OUString* pIconName, VirtualDevice* pImageSurface,
2992 TriState eCheckRadioFalse)
2993 {
2994 m_nLastId = insert_to_menu(m_nLastId, m_xMenuButton->GetPopupMenu(), pos, rId, rStr, pIconName,
2995 pImageSurface, nullptr, eCheckRadioFalse);
2996 }
2997
2998 void SalInstanceMenuButton::insert_separator(int pos, const OUString& rId)
2999 {
3000 auto nInsertPos = pos == -1 ? MENU_APPEND : pos;
3001 m_xMenuButton->GetPopupMenu()->InsertSeparator(rId, nInsertPos);
3002 }
3003
3004 void SalInstanceMenuButton::set_item_sensitive(const OUString& rIdent, bool bSensitive)
3005 {
3006 PopupMenu* pMenu = m_xMenuButton->GetPopupMenu();
3007 pMenu->EnableItem(rIdent, bSensitive);
3008 }
3009
3010 void SalInstanceMenuButton::remove_item(const OUString& rId)
3011 {
3012 PopupMenu* pMenu = m_xMenuButton->GetPopupMenu();
3013 pMenu->RemoveItem(pMenu->GetItemPos(pMenu->GetItemId(rId)));
3014 }
3015
3016 void SalInstanceMenuButton::clear()
3017 {
3018 PopupMenu* pMenu = m_xMenuButton->GetPopupMenu();
3019 pMenu->Clear();
3020 }
3021
3022 void SalInstanceMenuButton::set_item_active(const OUString& rIdent, bool bActive)
3023 {
3024 PopupMenu* pMenu = m_xMenuButton->GetPopupMenu();
3025 pMenu->CheckItem(rIdent, bActive);
3026 }
3027
3028 void SalInstanceMenuButton::set_item_label(const OUString& rIdent, const OUString& rText)
3029 {
3030 PopupMenu* pMenu = m_xMenuButton->GetPopupMenu();
3031 pMenu->SetItemText(pMenu->GetItemId(rIdent), rText);
3032 }
3033
3034 OUString SalInstanceMenuButton::get_item_label(const OUString& rIdent) const
3035 {
3036 PopupMenu* pMenu = m_xMenuButton->GetPopupMenu();
3037 return pMenu->GetItemText(pMenu->GetItemId(rIdent));
3038 }
3039
3040 void SalInstanceMenuButton::set_item_visible(const OUString& rIdent, bool bShow)
3041 {
3042 PopupMenu* pMenu = m_xMenuButton->GetPopupMenu();
3043 pMenu->ShowItem(pMenu->GetItemId(rIdent), bShow);
3044 }
3045
3046 void SalInstanceMenuButton::set_popover(weld::Widget* pPopover)
3047 {
3048 SalInstanceWidget* pPopoverWidget = dynamic_cast<SalInstanceWidget*>(pPopover);
3049 m_xMenuButton->SetPopover(pPopoverWidget ? pPopoverWidget->getWidget() : nullptr);
3050 }
3051
3052 SalInstanceMenuButton::~SalInstanceMenuButton()
3053 {
3054 m_xMenuButton->SetSelectHdl(Link<::MenuButton*, void>());
3055 m_xMenuButton->SetActivateHdl(Link<::MenuButton*, void>());
3056 }
3057
3058 IMPL_LINK_NOARG(SalInstanceMenuButton, MenuSelectHdl, ::MenuButton*, void)
3059 {
3060 signal_selected(m_xMenuButton->GetCurItemIdent());
3061 }
3062
3063 IMPL_LINK_NOARG(SalInstanceMenuButton, ActivateHdl, ::MenuButton*, void)
3064 {
3065 if (notify_events_disabled())
3066 return;
3067 signal_toggled();
3068 }
3069
3070 namespace
3071 {
3072 class SalInstanceMenuToggleButton : public SalInstanceMenuButton,
3073 public virtual weld::MenuToggleButton
3074 {
3075 private:
3076 VclPtr<::MenuToggleButton> m_xMenuToggleButton;
3077
3078 public:
3079 SalInstanceMenuToggleButton(::MenuToggleButton* pButton, SalInstanceBuilder* pBuilder,
3080 bool bTakeOwnership)
3081 : SalInstanceMenuButton(pButton, pBuilder, bTakeOwnership)
3082 , m_xMenuToggleButton(pButton)
3083 {
3084 m_xMenuToggleButton->SetDelayMenu(true);
3085 m_xMenuToggleButton->SetDropDown(PushButtonDropdownStyle::SplitMenuButton);
3086 }
3087
3088 virtual void set_active(bool active) override
3089 {
3090 disable_notify_events();
3091 m_xMenuToggleButton->SetActive(active);
3092 enable_notify_events();
3093 }
3094
3095 virtual bool get_active() const override { return m_xMenuToggleButton->GetActive(); }
3096 };
3097 }
3098
3099 IMPL_LINK(SalInstanceLinkButton, ClickHdl, FixedHyperlink&, rButton, void)
3100 {
3101 bool bConsumed = signal_activate_link();
3102 if (!bConsumed)
3103 m_aOrigClickHdl.Call(rButton);
3104 }
3105
3106 void SalInstanceLinkButton::set_label_wrap(bool bWrap) { ::set_label_wrap(*m_xButton, bWrap); }
3107
3108 SalInstanceRadioButton::SalInstanceRadioButton(::RadioButton* pButton, SalInstanceBuilder* pBuilder,
3109 bool bTakeOwnership)
3110 : SalInstanceButton(pButton, pBuilder, bTakeOwnership)
3111 , m_xRadioButton(pButton)
3112 {
3113 m_xRadioButton->SetToggleHdl(LINK(this, SalInstanceRadioButton, ToggleHdl));
3114 }
3115
3116 void SalInstanceRadioButton::set_active(bool active)
3117 {
3118 disable_notify_events();
3119 m_xRadioButton->Check(active);
3120 enable_notify_events();
3121 }
3122
3123 bool SalInstanceRadioButton::get_active() const { return m_xRadioButton->IsChecked(); }
3124
3125 void SalInstanceRadioButton::set_image(VirtualDevice* pDevice)
3126 {
3127 m_xRadioButton->SetImageAlign(ImageAlign::Center);
3128 if (pDevice)
3129 m_xRadioButton->SetModeImage(createImage(*pDevice));
3130 else
3131 m_xRadioButton->SetModeImage(Image());
3132 }
3133
3134 void SalInstanceRadioButton::set_image(const css::uno::Reference<css::graphic::XGraphic>& rImage)
3135 {
3136 m_xRadioButton->SetImageAlign(ImageAlign::Center);
3137 m_xRadioButton->SetModeImage(Image(rImage));
3138 }
3139
3140 void SalInstanceRadioButton::set_from_icon_name(const OUString& rIconName)
3141 {
3142 m_xRadioButton->SetModeRadioImage(Image(StockImage::Yes, rIconName));
3143 }
3144
3145 void SalInstanceRadioButton::set_inconsistent(bool /*inconsistent*/)
3146 {
3147 //not available
3148 }
3149
3150 bool SalInstanceRadioButton::get_inconsistent() const { return false; }
3151
3152 void SalInstanceRadioButton::set_label_wrap(bool bWrap)
3153 {
3154 ::set_label_wrap(*m_xRadioButton, bWrap);
3155 }
3156
3157 SalInstanceRadioButton::~SalInstanceRadioButton()
3158 {
3159 m_xRadioButton->SetToggleHdl(Link<::RadioButton&, void>());
3160 }
3161
3162 IMPL_LINK_NOARG(SalInstanceRadioButton, ToggleHdl, ::RadioButton&, void)
3163 {
3164 if (notify_events_disabled())
3165 return;
3166 signal_toggled();
3167 }
3168
3169 IMPL_LINK(SalInstanceToggleButton, ToggleListener, VclWindowEvent&, rEvent, void)
3170 {
3171 if (notify_events_disabled())
3172 return;
3173 if (rEvent.GetId() == VclEventId::PushbuttonToggle)
3174 signal_toggled();
3175 }
3176
3177 SalInstanceCheckButton::SalInstanceCheckButton(CheckBox* pButton, SalInstanceBuilder* pBuilder,
3178 bool bTakeOwnership)
3179 : SalInstanceButton(pButton, pBuilder, bTakeOwnership)
3180 , m_xCheckButton(pButton)
3181 {
3182 m_xCheckButton->SetToggleHdl(LINK(this, SalInstanceCheckButton, ToggleHdl));
3183 }
3184
3185 void SalInstanceCheckButton::set_active(bool active)
3186 {
3187 disable_notify_events();
3188 m_xCheckButton->EnableTriState(false);
3189 m_xCheckButton->Check(active);
3190 enable_notify_events();
3191 }
3192
3193 bool SalInstanceCheckButton::get_active() const { return m_xCheckButton->IsChecked(); }
3194
3195 void SalInstanceCheckButton::set_inconsistent(bool inconsistent)
3196 {
3197 disable_notify_events();
3198 m_xCheckButton->EnableTriState(true);
3199 m_xCheckButton->SetState(inconsistent ? TRISTATE_INDET : TRISTATE_FALSE);
3200 enable_notify_events();
3201 }
3202
3203 bool SalInstanceCheckButton::get_inconsistent() const
3204 {
3205 return m_xCheckButton->GetState() == TRISTATE_INDET;
3206 }
3207
3208 void SalInstanceCheckButton::set_label_wrap(bool bWrap)
3209 {
3210 ::set_label_wrap(*m_xCheckButton, bWrap);
3211 }
3212
3213 SalInstanceCheckButton::~SalInstanceCheckButton()
3214 {
3215 m_xCheckButton->SetToggleHdl(Link<CheckBox&, void>());
3216 }
3217
3218 IMPL_LINK_NOARG(SalInstanceCheckButton, ToggleHdl, CheckBox&, void)
3219 {
3220 if (notify_events_disabled())
3221 return;
3222 m_xCheckButton->EnableTriState(false);
3223 signal_toggled();
3224 }
3225
3226 namespace
3227 {
3228 class SalInstanceScale : public SalInstanceWidget, public virtual weld::Scale
3229 {
3230 private:
3231 VclPtr<Slider> m_xScale;
3232
3233 DECL_LINK(SlideHdl, Slider*, void);
3234
3235 public:
3236 SalInstanceScale(Slider* pScale, SalInstanceBuilder* pBuilder, bool bTakeOwnership)
3237 : SalInstanceWidget(pScale, pBuilder, bTakeOwnership)
3238 , m_xScale(pScale)
3239 {
3240 m_xScale->SetSlideHdl(LINK(this, SalInstanceScale, SlideHdl));
3241 }
3242
3243 virtual void set_value(int value) override { m_xScale->SetThumbPos(value); }
3244
3245 virtual void set_range(int min, int max) override
3246 {
3247 m_xScale->SetRangeMin(min);
3248 m_xScale->SetRangeMax(max);
3249 }
3250
3251 virtual int get_value() const override { return m_xScale->GetThumbPos(); }
3252
3253 virtual void set_increments(int step, int page) override
3254 {
3255 m_xScale->SetLineSize(step);
3256 m_xScale->SetPageSize(page);
3257 }
3258
3259 virtual void get_increments(int& step, int& page) const override
3260 {
3261 step = m_xScale->GetLineSize();
3262 page = m_xScale->GetPageSize();
3263 }
3264
3265 virtual ~SalInstanceScale() override { m_xScale->SetSlideHdl(Link<Slider*, void>()); }
3266 };
3267 }
3268
3269 IMPL_LINK_NOARG(SalInstanceScale, SlideHdl, Slider*, void) { signal_value_changed(); }
3270
3271 namespace
3272 {
3273 class SalInstanceSpinner : public SalInstanceWidget, public virtual weld::Spinner
3274 {
3275 private:
3276 VclPtr<Throbber> m_xThrobber;
3277
3278 public:
3279 SalInstanceSpinner(Throbber* pThrobber, SalInstanceBuilder* pBuilder, bool bTakeOwnership)
3280 : SalInstanceWidget(pThrobber, pBuilder, bTakeOwnership)
3281 , m_xThrobber(pThrobber)
3282 {
3283 }
3284
3285 virtual void start() override { m_xThrobber->start(); }
3286
3287 virtual void stop() override { m_xThrobber->stop(); }
3288 };
3289
3290 class SalInstanceProgressBar : public SalInstanceWidget, public virtual weld::ProgressBar
3291 {
3292 private:
3293 VclPtr<::ProgressBar> m_xProgressBar;
3294
3295 public:
3296 SalInstanceProgressBar(::ProgressBar* pProgressBar, SalInstanceBuilder* pBuilder,
3297 bool bTakeOwnership)
3298 : SalInstanceWidget(pProgressBar, pBuilder, bTakeOwnership)
3299 , m_xProgressBar(pProgressBar)
3300 {
3301 }
3302
3303 virtual void set_percentage(int value) override { m_xProgressBar->SetValue(value); }
3304
3305 virtual OUString get_text() const override { return m_xProgressBar->GetText(); }
3306
3307 virtual void set_text(const OUString& rText) override { m_xProgressBar->SetText(rText); }
3308 };
3309
3310 class SalInstanceCalendar : public SalInstanceWidget, public virtual weld::Calendar
3311 {
3312 private:
3313 VclPtr<::Calendar> m_xCalendar;
3314
3315 DECL_LINK(SelectHdl, ::Calendar*, void);
3316 DECL_LINK(ActivateHdl, ::Calendar*, void);
3317
3318 public:
3319 SalInstanceCalendar(::Calendar* pCalendar, SalInstanceBuilder* pBuilder, bool bTakeOwnership)
3320 : SalInstanceWidget(pCalendar, pBuilder, bTakeOwnership)
3321 , m_xCalendar(pCalendar)
3322 {
3323 m_xCalendar->SetSelectHdl(LINK(this, SalInstanceCalendar, SelectHdl));
3324 m_xCalendar->SetActivateHdl(LINK(this, SalInstanceCalendar, ActivateHdl));
3325 }
3326
3327 virtual void set_date(const Date& rDate) override { m_xCalendar->SetCurDate(rDate); }
3328
3329 virtual Date get_date() const override { return m_xCalendar->GetFirstSelectedDate(); }
3330
3331 virtual ~SalInstanceCalendar() override
3332 {
3333 m_xCalendar->SetSelectHdl(Link<::Calendar*, void>());
3334 m_xCalendar->SetActivateHdl(Link<::Calendar*, void>());
3335 }
3336 };
3337 }
3338
3339 IMPL_LINK_NOARG(SalInstanceCalendar, SelectHdl, ::Calendar*, void)
3340 {
3341 if (notify_events_disabled())
3342 return;
3343 signal_selected();
3344 }
3345
3346 IMPL_LINK_NOARG(SalInstanceCalendar, ActivateHdl, ::Calendar*, void)
3347 {
3348 if (notify_events_disabled())
3349 return;
3350 signal_activated();
3351 }
3352
3353 SalInstanceImage::SalInstanceImage(FixedImage* pImage, SalInstanceBuilder* pBuilder,
3354 bool bTakeOwnership)
3355 : SalInstanceWidget(pImage, pBuilder, bTakeOwnership)
3356 , m_xImage(pImage)
3357 {
3358 }
3359
3360 void SalInstanceImage::set_from_icon_name(const OUString& rIconName)
3361 {
3362 m_xImage->SetImage(::Image(StockImage::Yes, rIconName));
3363 }
3364
3365 void SalInstanceImage::set_image(VirtualDevice* pDevice)
3366 {
3367 if (pDevice)
3368 m_xImage->SetImage(createImage(*pDevice));
3369 else
3370 m_xImage->SetImage(::Image());
3371 }
3372
3373 void SalInstanceImage::set_image(const css::uno::Reference<css::graphic::XGraphic>& rImage)
3374 {
3375 m_xImage->SetImage(::Image(rImage));
3376 }
3377
3378 WeldTextFilter::WeldTextFilter(Link<OUString&, bool>& rInsertTextHdl)
3379 : TextFilter(OUString())
3380 , m_rInsertTextHdl(rInsertTextHdl)
3381 {
3382 }
3383
3384 OUString WeldTextFilter::filter(const OUString& rText)
3385 {
3386 if (!m_rInsertTextHdl.IsSet())
3387 return rText;
3388 OUString sText(rText);
3389 const bool bContinue = m_rInsertTextHdl.Call(sText);
3390 if (!bContinue)
3391 return OUString();
3392 return sText;
3393 }
3394
3395 SalInstanceEntry::SalInstanceEntry(Edit* pEntry, SalInstanceBuilder* pBuilder, bool bTakeOwnership)
3396 : SalInstanceWidget(pEntry, pBuilder, bTakeOwnership)
3397 , m_xEntry(pEntry)
3398 , m_aTextFilter(m_aInsertTextHdl)
3399 {
3400 m_xEntry->SetModifyHdl(LINK(this, SalInstanceEntry, ChangeHdl));
3401 m_xEntry->SetActivateHdl(LINK(this, SalInstanceEntry, ActivateHdl));
3402 m_xEntry->SetTextFilter(&m_aTextFilter);
3403 }
3404
3405 void SalInstanceEntry::set_text(const OUString& rText)
3406 {
3407 disable_notify_events();
3408 m_xEntry->SetText(rText);
3409 enable_notify_events();
3410 }
3411
3412 OUString SalInstanceEntry::get_text() const { return m_xEntry->GetText(); }
3413
3414 void SalInstanceEntry::set_width_chars(int nChars) { m_xEntry->SetWidthInChars(nChars); }
3415
3416 int SalInstanceEntry::get_width_chars() const { return m_xEntry->GetWidthInChars(); }
3417
3418 void SalInstanceEntry::set_max_length(int nChars) { m_xEntry->SetMaxTextLen(nChars); }
3419
3420 void SalInstanceEntry::select_region(int nStartPos, int nEndPos)
3421 {
3422 disable_notify_events();
3423 tools::Long nStart = nStartPos < 0 ? SELECTION_MAX : nStartPos;
3424 tools::Long nEnd = nEndPos < 0 ? SELECTION_MAX : nEndPos;
3425 m_xEntry->SetSelection(Selection(nStart, nEnd));
3426 enable_notify_events();
3427 }
3428
3429 bool SalInstanceEntry::get_selection_bounds(int& rStartPos, int& rEndPos)
3430 {
3431 const Selection& rSelection = m_xEntry->GetSelection();
3432 rStartPos = rSelection.Min();
3433 rEndPos = rSelection.Max();
3434 return rSelection.Len();
3435 }
3436
3437 void SalInstanceEntry::replace_selection(const OUString& rText)
3438 {
3439 m_xEntry->ReplaceSelected(rText);
3440 }
3441
3442 void SalInstanceEntry::set_position(int nCursorPos)
3443 {
3444 disable_notify_events();
3445 if (nCursorPos < 0)
3446 m_xEntry->SetCursorAtLast();
3447 else
3448 m_xEntry->SetSelection(Selection(nCursorPos, nCursorPos));
3449 enable_notify_events();
3450 }
3451
3452 int SalInstanceEntry::get_position() const { return m_xEntry->GetSelection().Max(); }
3453
3454 void SalInstanceEntry::set_editable(bool bEditable) { m_xEntry->SetReadOnly(!bEditable); }
3455
3456 bool SalInstanceEntry::get_editable() const { return !m_xEntry->IsReadOnly(); }
3457
3458 void SalInstanceEntry::set_overwrite_mode(bool bOn) { m_xEntry->SetInsertMode(!bOn); }
3459
3460 bool SalInstanceEntry::get_overwrite_mode() const { return !m_xEntry->IsInsertMode(); }
3461
3462 namespace
3463 {
3464 void set_message_type(Edit* pEntry, weld::EntryMessageType eType)
3465 {
3466 switch (eType)
3467 {
3468 case weld::EntryMessageType::Normal:
3469 pEntry->SetForceControlBackground(false);
3470 pEntry->SetControlForeground();
3471 pEntry->SetControlBackground();
3472 break;
3473 case weld::EntryMessageType::Warning:
3474 // tdf#114603: enable setting the background to a different color;
3475 // relevant for GTK; see also #i75179#
3476 pEntry->SetForceControlBackground(true);
3477 pEntry->SetControlForeground(COL_BLACK);
3478 pEntry->SetControlBackground(0xffff38); // "light yellow 1"
3479 break;
3480 case weld::EntryMessageType::Error:
3481 // tdf#114603: enable setting the background to a different color;
3482 // relevant for GTK; see also #i75179#
3483 pEntry->SetForceControlBackground(true);
3484 pEntry->SetControlForeground(COL_BLACK); // contrast of 5.87 to the red background
3485 pEntry->SetControlBackground(0xff3838); // "light red 1"
3486 break;
3487 }
3488 }
3489 }
3490
3491 void SalInstanceEntry::set_message_type(weld::EntryMessageType eType)
3492 {
3493 ::set_message_type(m_xEntry, eType);
3494 }
3495
3496 void SalInstanceEntry::set_font(const vcl::Font& rFont)
3497 {
3498 m_xEntry->SetControlFont(rFont);
3499 m_xEntry->Invalidate();
3500 }
3501
3502 void SalInstanceEntry::set_font_color(const Color& rColor)
3503 {
3504 if (rColor == COL_AUTO)
3505 m_xEntry->SetControlForeground();
3506 else
3507 m_xEntry->SetControlForeground(rColor);
3508 }
3509
3510 void SalInstanceEntry::connect_cursor_position(const Link<Entry&, void>& rLink)
3511 {
3512 assert(!m_aCursorPositionHdl.IsSet());
3513 m_xEntry->AddEventListener(LINK(this, SalInstanceEntry, CursorListener));
3514 weld::Entry::connect_cursor_position(rLink);
3515 }
3516
3517 void SalInstanceEntry::set_placeholder_text(const OUString& rText)
3518 {
3519 m_xEntry->SetPlaceholderText(rText);
3520 }
3521
3522 Edit& SalInstanceEntry::getEntry() { return *m_xEntry; }
3523
3524 void SalInstanceEntry::fire_signal_changed() { signal_changed(); }
3525
3526 void SalInstanceEntry::cut_clipboard()
3527 {
3528 m_xEntry->Cut();
3529 m_xEntry->Modify();
3530 }
3531
3532 void SalInstanceEntry::copy_clipboard() { m_xEntry->Copy(); }
3533
3534 void SalInstanceEntry::paste_clipboard()
3535 {
3536 m_xEntry->Paste();
3537 m_xEntry->Modify();
3538 }
3539
3540 namespace
3541 {
3542 void set_alignment(Edit& rEntry, TxtAlign eXAlign)
3543 {
3544 WinBits nAlign(0);
3545 switch (eXAlign)
3546 {
3547 case TxtAlign::Left:
3548 nAlign = WB_LEFT;
3549 break;
3550 case TxtAlign::Center:
3551 nAlign = WB_CENTER;
3552 break;
3553 case TxtAlign::Right:
3554 nAlign = WB_RIGHT;
3555 break;
3556 }
3557 WinBits nBits = rEntry.GetStyle();
3558 nBits &= ~(WB_LEFT | WB_CENTER | WB_RIGHT);
3559 rEntry.SetStyle(nBits | nAlign);
3560 }
3561 }
3562
3563 void SalInstanceEntry::set_alignment(TxtAlign eXAlign) { ::set_alignment(*m_xEntry, eXAlign); }
3564
3565 SalInstanceEntry::~SalInstanceEntry()
3566 {
3567 if (m_aCursorPositionHdl.IsSet())
3568 m_xEntry->RemoveEventListener(LINK(this, SalInstanceEntry, CursorListener));
3569 m_xEntry->SetTextFilter(nullptr);
3570 m_xEntry->SetActivateHdl(Link<Edit&, bool>());
3571 m_xEntry->SetModifyHdl(Link<Edit&, void>());
3572 }
3573
3574 IMPL_LINK_NOARG(SalInstanceEntry, ChangeHdl, Edit&, void) { signal_changed(); }
3575
3576 IMPL_LINK(SalInstanceEntry, CursorListener, VclWindowEvent&, rEvent, void)
3577 {
3578 if (notify_events_disabled())
3579 return;
3580 if (rEvent.GetId() == VclEventId::EditSelectionChanged
3581 || rEvent.GetId() == VclEventId::EditCaretChanged)
3582 signal_cursor_position();
3583 }
3584
3585 IMPL_LINK_NOARG(SalInstanceEntry, ActivateHdl, Edit&, bool) { return m_aActivateHdl.Call(*this); }
3586
3587 class SalInstanceTreeView;
3588
3589 static SalInstanceTreeView* g_DragSource;
3590
3591 namespace
3592 {
3593 // tdf#131581 if the TreeView is hidden then there are possibly additional
3594 // optimizations available
3595 class UpdateGuardIfHidden
3596 {
3597 private:
3598 SvTabListBox& m_rTreeView;
3599 bool m_bOrigUpdate;
3600 bool m_bOrigEnableInvalidate;
3601
3602 public:
3603 UpdateGuardIfHidden(SvTabListBox& rTreeView)
3604 : m_rTreeView(rTreeView)
3605 // tdf#136962 only do SetUpdateMode(false) optimization if the widget is currently hidden
3606 , m_bOrigUpdate(!m_rTreeView.IsVisible() && m_rTreeView.IsUpdateMode())
3607 // tdf#137432 only do EnableInvalidate(false) optimization if the widget is currently hidden
3608 , m_bOrigEnableInvalidate(!m_rTreeView.IsVisible()
3609 && m_rTreeView.GetModel()->IsEnableInvalidate())
3610 {
3611 if (m_bOrigUpdate)
3612 m_rTreeView.SetUpdateMode(false);
3613 if (m_bOrigEnableInvalidate)
3614 m_rTreeView.GetModel()->EnableInvalidate(false);
3615 }
3616
3617 ~UpdateGuardIfHidden()
3618 {
3619 if (m_bOrigEnableInvalidate)
3620 m_rTreeView.GetModel()->EnableInvalidate(true);
3621 if (m_bOrigUpdate)
3622 m_rTreeView.SetUpdateMode(true);
3623 }
3624 };
3625 }
3626
3627 // Each row has a cell for the expander image, (and an optional cell for a
3628 // checkbutton if enable_toggle_buttons has been called) which precede
3629 // index 0
3630 int SalInstanceTreeView::to_internal_model(int col) const
3631 {
3632 if (m_xTreeView->nTreeFlags & SvTreeFlags::CHKBTN)
3633 ++col; // skip checkbutton column
3634 ++col; //skip expander column
3635 return col;
3636 }
3637
3638 int SalInstanceTreeView::to_external_model(int col) const
3639 {
3640 if (m_xTreeView->nTreeFlags & SvTreeFlags::CHKBTN)
3641 --col; // skip checkbutton column
3642 --col; //skip expander column
3643 return col;
3644 }
3645
3646 bool SalInstanceTreeView::IsDummyEntry(SvTreeListEntry* pEntry) const
3647 {
3648 return o3tl::trim(m_xTreeView->GetEntryText(pEntry)) == u"<dummy>";
3649 }
3650
3651 SvTreeListEntry* SalInstanceTreeView::GetPlaceHolderChild(SvTreeListEntry* pEntry) const
3652 {
3653 if (pEntry->HasChildren())
3654 {
3655 auto pChild = m_xTreeView->FirstChild(pEntry);
3656 assert(pChild);
3657 if (IsDummyEntry(pChild))
3658 return pChild;
3659 }
3660 return nullptr;
3661 }
3662
3663 void SalInstanceTreeView::set_font_color(SvTreeListEntry* pEntry, const Color& rColor)
3664 {
3665 if (rColor == COL_AUTO)
3666 pEntry->SetTextColor(std::optional<Color>());
3667 else
3668 pEntry->SetTextColor(rColor);
3669 }
3670
3671 void SalInstanceTreeView::AddStringItem(SvTreeListEntry* pEntry, const OUString& rStr, int nCol)
3672 {
3673 auto xCell = std::make_unique<SvLBoxString>(rStr);
3674 if (m_aCustomRenders.count(nCol))
3675 xCell->SetCustomRender();
3676 pEntry->AddItem(std::move(xCell));
3677 }
3678
3679 void SalInstanceTreeView::do_insert(const weld::TreeIter* pParent, int pos, const OUString* pStr,
3680 const OUString* pId, const OUString* pIconName,
3681 const VirtualDevice* pImageSurface, bool bChildrenOnDemand,
3682 weld::TreeIter* pRet, bool bIsSeparator)
3683 {
3684 disable_notify_events();
3685 const SalInstanceTreeIter* pVclIter = static_cast<const SalInstanceTreeIter*>(pParent);
3686 SvTreeListEntry* iter = pVclIter ? pVclIter->iter : nullptr;
3687 auto nInsertPos = pos == -1 ? TREELIST_APPEND : pos;
3688 void* pUserData;
3689 if (pId)
3690 {
3691 m_aUserData.emplace_back(std::make_unique<OUString>(*pId));
3692 pUserData = m_aUserData.back().get();
3693 }
3694 else
3695 pUserData = nullptr;
3696
3697 SvTreeListEntry* pEntry = new SvTreeListEntry;
3698 if (bIsSeparator)
3699 pEntry->SetFlags(pEntry->GetFlags() | SvTLEntryFlags::IS_SEPARATOR);
3700
3701 if (m_xTreeView->nTreeFlags & SvTreeFlags::CHKBTN)
3702 AddStringItem(pEntry, "", -1);
3703
3704 if (pIconName || pImageSurface)
3705 {
3706 Image aImage(pIconName ? createImage(*pIconName) : createImage(*pImageSurface));
3707 pEntry->AddItem(std::make_unique<SvLBoxContextBmp>(aImage, aImage, false));
3708 }
3709 else
3710 {
3711 Image aDummy;
3712 pEntry->AddItem(std::make_unique<SvLBoxContextBmp>(aDummy, aDummy, false));
3713 }
3714 if (pStr)
3715 AddStringItem(pEntry, *pStr, pEntry->ItemCount());
3716 pEntry->SetUserData(pUserData);
3717 m_xTreeView->Insert(pEntry, iter, nInsertPos);
3718
3719 if (pRet)
3720 {
3721 SalInstanceTreeIter* pVclRetIter = static_cast<SalInstanceTreeIter*>(pRet);
3722 pVclRetIter->iter = pEntry;
3723 }
3724
3725 if (bChildrenOnDemand)
3726 {
3727 SvTreeListEntry* pPlaceHolder
3728 = m_xTreeView->InsertEntry("<dummy>", pEntry, false, 0, nullptr);
3729 SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pPlaceHolder);
3730 pViewData->SetSelectable(false);
3731 }
3732
3733 if (bIsSeparator)
3734 {
3735 SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pEntry);
3736 pViewData->SetSelectable(false);
3737 }
3738
3739 enable_notify_events();
3740 }
3741
3742 void SalInstanceTreeView::update_checkbutton_column_width(SvTreeListEntry* pEntry)
3743 {
3744 SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pEntry);
3745 m_xTreeView->InitViewData(pViewData, pEntry);
3746 m_xTreeView->CheckBoxInserted(pEntry);
3747 }
3748
3749 void SalInstanceTreeView::InvalidateModelEntry(SvTreeListEntry* pEntry)
3750 {
3751 if (!m_xTreeView->GetModel()->IsEnableInvalidate())
3752 return;
3753 m_xTreeView->ModelHasEntryInvalidated(pEntry);
3754 }
3755
3756 void SalInstanceTreeView::do_set_toggle(SvTreeListEntry* pEntry, TriState eState, int col)
3757 {
3758 assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount());
3759 // if it's the placeholder to allow a blank column, replace it now
3760 if (pEntry->GetItem(col).GetType() != SvLBoxItemType::Button)
3761 {
3762 SvLBoxButtonData* pData = m_bTogglesAsRadio ? &m_aRadioButtonData : &m_aCheckButtonData;
3763 pEntry->ReplaceItem(std::make_unique<SvLBoxButton>(pData), 0);
3764 update_checkbutton_column_width(pEntry);
3765 }
3766 SvLBoxItem& rItem = pEntry->GetItem(col);
3767 assert(dynamic_cast<SvLBoxButton*>(&rItem));
3768 switch (eState)
3769 {
3770 case TRISTATE_TRUE:
3771 static_cast<SvLBoxButton&>(rItem).SetStateChecked();
3772 break;
3773 case TRISTATE_FALSE:
3774 static_cast<SvLBoxButton&>(rItem).SetStateUnchecked();
3775 break;
3776 case TRISTATE_INDET:
3777 static_cast<SvLBoxButton&>(rItem).SetStateTristate();
3778 break;
3779 }
3780
3781 InvalidateModelEntry(pEntry);
3782 }
3783
3784 TriState SalInstanceTreeView::do_get_toggle(SvTreeListEntry* pEntry, int col)
3785 {
3786 if (static_cast<size_t>(col) == pEntry->ItemCount())
3787 return TRISTATE_FALSE;
3788
3789 assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount());
3790 SvLBoxItem& rItem = pEntry->GetItem(col);
3791 assert(dynamic_cast<SvLBoxButton*>(&rItem));
3792 SvLBoxButton& rToggle = static_cast<SvLBoxButton&>(rItem);
3793 if (rToggle.IsStateTristate())
3794 return TRISTATE_INDET;
3795 else if (rToggle.IsStateChecked())
3796 return TRISTATE_TRUE;
3797 return TRISTATE_FALSE;
3798 }
3799
3800 TriState SalInstanceTreeView::get_toggle(SvTreeListEntry* pEntry, int col) const
3801 {
3802 if (col == -1)
3803 {
3804 assert(m_xTreeView->nTreeFlags & SvTreeFlags::CHKBTN);
3805 return do_get_toggle(pEntry, 0);
3806 }
3807 col = to_internal_model(col);
3808 return do_get_toggle(pEntry, col);
3809 }
3810
3811 void SalInstanceTreeView::set_toggle(SvTreeListEntry* pEntry, TriState eState, int col)
3812 {
3813 if (col == -1)
3814 {
3815 assert(m_xTreeView->nTreeFlags & SvTreeFlags::CHKBTN);
3816 do_set_toggle(pEntry, eState, 0);
3817 return;
3818 }
3819
3820 col = to_internal_model(col);
3821
3822 // blank out missing entries
3823 for (int i = pEntry->ItemCount(); i < col; ++i)
3824 AddStringItem(pEntry, "", i - 1);
3825
3826 if (static_cast<size_t>(col) == pEntry->ItemCount())
3827 {
3828 SvLBoxButtonData* pData = m_bTogglesAsRadio ? &m_aRadioButtonData : &m_aCheckButtonData;
3829 pEntry->AddItem(std::make_unique<SvLBoxButton>(pData));
3830 update_checkbutton_column_width(pEntry);
3831 }
3832
3833 do_set_toggle(pEntry, eState, col);
3834 }
3835
3836 bool SalInstanceTreeView::get_text_emphasis(SvTreeListEntry* pEntry, int col) const
3837 {
3838 col = to_internal_model(col);
3839
3840 assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount());
3841 SvLBoxItem& rItem = pEntry->GetItem(col);
3842 assert(dynamic_cast<SvLBoxString*>(&rItem));
3843 return static_cast<SvLBoxString&>(rItem).IsEmphasized();
3844 }
3845
3846 void SalInstanceTreeView::set_header_item_width(const std::vector<int>& rWidths)
3847 {
3848 LclHeaderTabListBox* pHeaderBox = dynamic_cast<LclHeaderTabListBox*>(m_xTreeView.get());
3849 if (HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr)
3850 {
3851 for (size_t i = 0; i < rWidths.size(); ++i)
3852 pHeaderBar->SetItemSize(pHeaderBar->GetItemId(i), rWidths[i]);
3853 }
3854 }
3855
3856 SalInstanceTreeView::SalInstanceTreeView(SvTabListBox* pTreeView, SalInstanceBuilder* pBuilder,
3857 bool bTakeOwnership)
3858 : SalInstanceWidget(pTreeView, pBuilder, bTakeOwnership)
3859 , m_xTreeView(pTreeView)
3860 , m_aCheckButtonData(pTreeView, false)
3861 , m_aRadioButtonData(pTreeView, true)
3862 , m_bTogglesAsRadio(false)
3863 , m_nSortColumn(-1)
3864 {
3865 m_xTreeView->SetNodeDefaultImages();
3866 m_xTreeView->SetForceMakeVisible(true);
3867 m_xTreeView->SetSelectHdl(LINK(this, SalInstanceTreeView, SelectHdl));
3868 m_xTreeView->SetDeselectHdl(LINK(this, SalInstanceTreeView, DeSelectHdl));
3869 m_xTreeView->SetDoubleClickHdl(LINK(this, SalInstanceTreeView, DoubleClickHdl));
3870 m_xTreeView->SetExpandingHdl(LINK(this, SalInstanceTreeView, ExpandingHdl));
3871 m_xTreeView->SetPopupMenuHdl(LINK(this, SalInstanceTreeView, PopupMenuHdl));
3872 m_xTreeView->SetCustomRenderHdl(LINK(this, SalInstanceTreeView, CustomRenderHdl));
3873 m_xTreeView->SetCustomMeasureHdl(LINK(this, SalInstanceTreeView, CustomMeasureHdl));
3874 const tools::Long aTabPositions[] = { 0 };
3875 m_xTreeView->SetTabs(SAL_N_ELEMENTS(aTabPositions), aTabPositions);
3876 LclHeaderTabListBox* pHeaderBox = dynamic_cast<LclHeaderTabListBox*>(m_xTreeView.get());
3877
3878 if (pHeaderBox)
3879 {
3880 if (HeaderBar* pHeaderBar = pHeaderBox->GetHeaderBar())
3881 {
3882 //make the last entry fill available space
3883 pHeaderBar->SetItemSize(pHeaderBar->GetItemId(pHeaderBar->GetItemCount() - 1),
3884 HEADERBAR_FULLSIZE);
3885 pHeaderBar->SetEndDragHdl(LINK(this, SalInstanceTreeView, EndDragHdl));
3886 pHeaderBar->SetSelectHdl(LINK(this, SalInstanceTreeView, HeaderBarClickedHdl));
3887 }
3888 pHeaderBox->SetEditingEntryHdl(LINK(this, SalInstanceTreeView, EditingEntryHdl));
3889 pHeaderBox->SetEditedEntryHdl(LINK(this, SalInstanceTreeView, EditedEntryHdl));
3890 }
3891 else
3892 {
3893 static_cast<LclTabListBox&>(*m_xTreeView)
3894 .SetModelChangedHdl(LINK(this, SalInstanceTreeView, ModelChangedHdl));
3895 static_cast<LclTabListBox&>(*m_xTreeView)
3896 .SetStartDragHdl(LINK(this, SalInstanceTreeView, StartDragHdl));
3897 static_cast<LclTabListBox&>(*m_xTreeView)
3898 .SetEndDragHdl(LINK(this, SalInstanceTreeView, FinishDragHdl));
3899 static_cast<LclTabListBox&>(*m_xTreeView)
3900 .SetEditingEntryHdl(LINK(this, SalInstanceTreeView, EditingEntryHdl));
3901 static_cast<LclTabListBox&>(*m_xTreeView)
3902 .SetEditedEntryHdl(LINK(this, SalInstanceTreeView, EditedEntryHdl));
3903 }
3904 m_aCheckButtonData.SetLink(LINK(this, SalInstanceTreeView, ToggleHdl));
3905 m_aRadioButtonData.SetLink(LINK(this, SalInstanceTreeView, ToggleHdl));
3906 }
3907
3908 void SalInstanceTreeView::connect_query_tooltip(const Link<const weld::TreeIter&, OUString>& rLink)
3909 {
3910 weld::TreeView::connect_query_tooltip(rLink);
3911 m_xTreeView->SetTooltipHdl(LINK(this, SalInstanceTreeView, TooltipHdl));
3912 }
3913
3914 void SalInstanceTreeView::columns_autosize()
3915 {
3916 std::vector<tools::Long> aWidths;
3917 m_xTreeView->getPreferredDimensions(aWidths);
3918 if (aWidths.size() > 2)
3919 {
3920 std::vector<int> aColWidths;
3921 for (size_t i = 1; i < aWidths.size() - 1; ++i)
3922 aColWidths.push_back(aWidths[i] - aWidths[i - 1]);
3923 set_column_fixed_widths(aColWidths);
3924 }
3925 }
3926
3927 void SalInstanceTreeView::freeze()
3928 {
3929 bool bIsFirstFreeze = IsFirstFreeze();
3930 SalInstanceWidget::freeze();
3931 if (bIsFirstFreeze)
3932 {
3933 m_xTreeView->SetUpdateMode(false);
3934 m_xTreeView->GetModel()->EnableInvalidate(false);
3935 }
3936 }
3937
3938 void SalInstanceTreeView::thaw()
3939 {
3940 bool bIsLastThaw = IsLastThaw();
3941 if (bIsLastThaw)
3942 {
3943 m_xTreeView->GetModel()->EnableInvalidate(true);
3944 m_xTreeView->SetUpdateMode(true);
3945 }
3946 SalInstanceWidget::thaw();
3947 }
3948
3949 void SalInstanceTreeView::set_column_fixed_widths(const std::vector<int>& rWidths)
3950 {
3951 std::vector<tools::Long> aTabPositions{ 0 };
3952 for (size_t i = 0; i < rWidths.size(); ++i)
3953 aTabPositions.push_back(aTabPositions[i] + rWidths[i]);
3954 m_xTreeView->SetTabs(aTabPositions.size(), aTabPositions.data(), MapUnit::MapPixel);
3955 set_header_item_width(rWidths);
3956 // call Resize to recalculate based on the new tabs
3957 m_xTreeView->Resize();
3958 }
3959
3960 void SalInstanceTreeView::set_column_editables(const std::vector<bool>& rEditables)
3961 {
3962 size_t nTabCount = rEditables.size();
3963 for (size_t i = 0; i < nTabCount; ++i)
3964 m_xTreeView->SetTabEditable(i, rEditables[i]);
3965 }
3966
3967 void SalInstanceTreeView::set_centered_column(int nCol)
3968 {
3969 m_xTreeView->SetTabJustify(nCol, SvTabJustify::AdjustCenter);
3970 }
3971
3972 int SalInstanceTreeView::get_column_width(int nColumn) const
3973 {
3974 LclHeaderTabListBox* pHeaderBox = dynamic_cast<LclHeaderTabListBox*>(m_xTreeView.get());
3975 if (HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr)
3976 return pHeaderBar->GetItemSize(pHeaderBar->GetItemId(nColumn));
3977 // GetTab(0) gives the position of the bitmap which is automatically inserted by the TabListBox.
3978 // So the first text column's width is Tab(2)-Tab(1).
3979 auto nWidthPixel
3980 = m_xTreeView->GetLogicTab(nColumn + 2) - m_xTreeView->GetLogicTab(nColumn + 1);
3981 nWidthPixel -= SV_TAB_BORDER;
3982 return nWidthPixel;
3983 }
3984
3985 OUString SalInstanceTreeView::get_column_title(int nColumn) const
3986 {
3987 LclHeaderTabListBox* pHeaderBox = dynamic_cast<LclHeaderTabListBox*>(m_xTreeView.get());
3988 if (HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr)
3989 {
3990 return pHeaderBar->GetItemText(pHeaderBar->GetItemId(nColumn));
3991 }
3992 return OUString();
3993 }
3994
3995 void SalInstanceTreeView::set_column_title(int nColumn, const OUString& rTitle)
3996 {
3997 LclHeaderTabListBox* pHeaderBox = dynamic_cast<LclHeaderTabListBox*>(m_xTreeView.get());
3998 if (HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr)
3999 {
4000 return pHeaderBar->SetItemText(pHeaderBar->GetItemId(nColumn), rTitle);
4001 }
4002 }
4003
4004 void SalInstanceTreeView::set_column_custom_renderer(int nColumn, bool bEnable)
4005 {
4006 assert(n_children() == 0 && "tree must be empty");
4007 if (bEnable)
4008 m_aCustomRenders.insert(nColumn);
4009 else
4010 m_aCustomRenders.erase(nColumn);
4011 }
4012
4013 void SalInstanceTreeView::queue_draw()
4014 {
4015 // invalidate the entries
4016 SvTreeList* pModel = m_xTreeView->GetModel();
4017 for (SvTreeListEntry* pEntry = m_xTreeView->First(); pEntry; pEntry = m_xTreeView->Next(pEntry))
4018 pModel->InvalidateEntry(pEntry);
4019 }
4020
4021 void SalInstanceTreeView::show()
4022 {
4023 if (LclHeaderTabListBox* pHeaderBox = dynamic_cast<LclHeaderTabListBox*>(m_xTreeView.get()))
4024 pHeaderBox->GetParent()->Show();
4025 SalInstanceWidget::show();
4026 }
4027
4028 void SalInstanceTreeView::hide()
4029 {
4030 if (LclHeaderTabListBox* pHeaderBox = dynamic_cast<LclHeaderTabListBox*>(m_xTreeView.get()))
4031 pHeaderBox->GetParent()->Hide();
4032 SalInstanceWidget::hide();
4033 }
4034
4035 void SalInstanceTreeView::insert(const weld::TreeIter* pParent, int pos, const OUString* pStr,
4036 const OUString* pId, const OUString* pIconName,
4037 VirtualDevice* pImageSurface, bool bChildrenOnDemand,
4038 weld::TreeIter* pRet)
4039 {
4040 do_insert(pParent, pos, pStr, pId, pIconName, pImageSurface, bChildrenOnDemand, pRet, false);
4041 }
4042
4043 void SalInstanceTreeView::insert_separator(int pos, const OUString& /*rId*/)
4044 {
4045 OUString sSep(VclResId(STR_SEPARATOR));
4046 do_insert(nullptr, pos, &sSep, nullptr, nullptr, nullptr, false, nullptr, true);
4047 }
4048
4049 void SalInstanceTreeView::bulk_insert_for_each(
4050 int nSourceCount, const std::function<void(weld::TreeIter&, int nSourceIndex)>& func,
4051 const weld::TreeIter* pParent, const std::vector<int>* pFixedWidths)
4052 {
4053 const SalInstanceTreeIter* pVclIter = static_cast<const SalInstanceTreeIter*>(pParent);
4054 SvTreeListEntry* pVclParent = pVclIter ? pVclIter->iter : nullptr;
4055
4056 freeze();
4057 if (!pVclParent)
4058 clear();
4059 else
4060 {
4061 while (SvTreeListEntry* pChild = m_xTreeView->FirstChild(pVclParent))
4062 m_xTreeView->RemoveEntry(pChild);
4063 }
4064 SalInstanceTreeIter aVclIter(static_cast<SvTreeListEntry*>(nullptr));
4065
4066 m_xTreeView->nTreeFlags |= SvTreeFlags::MANINS;
4067
4068 if (pFixedWidths)
4069 set_header_item_width(*pFixedWidths);
4070
4071 bool bHasAutoCheckButton(m_xTreeView->nTreeFlags & SvTreeFlags::CHKBTN);
4072 size_t nExtraCols = bHasAutoCheckButton ? 2 : 1;
4073
4074 Image aDummy;
4075 for (int i = 0; i < nSourceCount; ++i)
4076 {
4077 aVclIter.iter = new SvTreeListEntry;
4078 if (bHasAutoCheckButton)
4079 AddStringItem(aVclIter.iter, "", -1);
4080 aVclIter.iter->AddItem(std::make_unique<SvLBoxContextBmp>(aDummy, aDummy, false));
4081 m_xTreeView->Insert(aVclIter.iter, pVclParent, TREELIST_APPEND);
4082 func(aVclIter, i);
4083
4084 if (!pFixedWidths)
4085 continue;
4086
4087 size_t nFixedWidths = std::min(pFixedWidths->size(), aVclIter.iter->ItemCount());
4088 for (size_t j = 0; j < nFixedWidths; ++j)
4089 {
4090 SvLBoxItem& rItem = aVclIter.iter->GetItem(j + nExtraCols);
4091 SvViewDataItem* pViewDataItem = m_xTreeView->GetViewDataItem(aVclIter.iter, &rItem);
4092 pViewDataItem->mnWidth = (*pFixedWidths)[j];
4093 }
4094 }
4095
4096 m_xTreeView->nTreeFlags &= ~SvTreeFlags::MANINS;
4097
4098 thaw();
4099 }
4100
4101 void SalInstanceTreeView::set_font_color(int pos, const Color& rColor)
4102 {
4103 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4104 set_font_color(pEntry, rColor);
4105 }
4106
4107 void SalInstanceTreeView::set_font_color(const weld::TreeIter& rIter, const Color& rColor)
4108 {
4109 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4110 set_font_color(rVclIter.iter, rColor);
4111 }
4112
4113 void SalInstanceTreeView::remove(int pos)
4114 {
4115 disable_notify_events();
4116 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4117 m_xTreeView->RemoveEntry(pEntry);
4118 enable_notify_events();
4119 }
4120
4121 int SalInstanceTreeView::find_text(const OUString& rText) const
4122 {
4123 for (SvTreeListEntry* pEntry = m_xTreeView->First(); pEntry; pEntry = m_xTreeView->Next(pEntry))
4124 {
4125 if (SvTabListBox::GetEntryText(pEntry, 0) == rText)
4126 return SvTreeList::GetRelPos(pEntry);
4127 }
4128 return -1;
4129 }
4130
4131 int SalInstanceTreeView::find_id(const OUString& rId) const
4132 {
4133 for (SvTreeListEntry* pEntry = m_xTreeView->First(); pEntry; pEntry = m_xTreeView->Next(pEntry))
4134 {
4135 const OUString* pId = static_cast<const OUString*>(pEntry->GetUserData());
4136 if (!pId)
4137 continue;
4138 if (rId == *pId)
4139 return SvTreeList::GetRelPos(pEntry);
4140 }
4141 return -1;
4142 }
4143
4144 void SalInstanceTreeView::swap(int pos1, int pos2)
4145 {
4146 int min = std::min(pos1, pos2);
4147 int max = std::max(pos1, pos2);
4148 SvTreeList* pModel = m_xTreeView->GetModel();
4149 SvTreeListEntry* pEntry1 = pModel->GetEntry(nullptr, min);
4150 SvTreeListEntry* pEntry2 = pModel->GetEntry(nullptr, max);
4151 pModel->Move(pEntry1, pEntry2);
4152 }
4153
4154 void SalInstanceTreeView::clear()
4155 {
4156 disable_notify_events();
4157 m_xTreeView->Clear();
4158 m_aUserData.clear();
4159 enable_notify_events();
4160 }
4161
4162 int SalInstanceTreeView::n_children() const
4163 {
4164 return m_xTreeView->GetModel()->GetChildList(nullptr).size();
4165 }
4166
4167 int SalInstanceTreeView::iter_n_children(const weld::TreeIter& rIter) const
4168 {
4169 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4170 return m_xTreeView->GetModel()->GetChildList(rVclIter.iter).size();
4171 }
4172
4173 void SalInstanceTreeView::select(int pos)
4174 {
4175 assert(m_xTreeView->IsUpdateMode()
4176 && "don't select when frozen, select after thaw. Note selection doesn't survive a "
4177 "freeze");
4178 disable_notify_events();
4179 if (pos == -1 || (pos == 0 && n_children() == 0))
4180 m_xTreeView->SelectAll(false);
4181 else
4182 {
4183 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4184 assert(pEntry && "bad pos?");
4185 m_xTreeView->Select(pEntry, true);
4186 m_xTreeView->MakeVisible(pEntry);
4187 }
4188 enable_notify_events();
4189 }
4190
4191 int SalInstanceTreeView::get_cursor_index() const
4192 {
4193 SvTreeListEntry* pEntry = m_xTreeView->GetCurEntry();
4194 if (!pEntry)
4195 return -1;
4196 return SvTreeList::GetRelPos(pEntry);
4197 }
4198
4199 void SalInstanceTreeView::set_cursor(int pos)
4200 {
4201 disable_notify_events();
4202 if (pos == -1)
4203 m_xTreeView->SetCurEntry(nullptr);
4204 else
4205 {
4206 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4207 m_xTreeView->SetCurEntry(pEntry);
4208 }
4209 enable_notify_events();
4210 }
4211
4212 void SalInstanceTreeView::scroll_to_row(int pos)
4213 {
4214 assert(m_xTreeView->IsUpdateMode()
4215 && "don't select when frozen, select after thaw. Note selection doesn't survive a "
4216 "freeze");
4217 disable_notify_events();
4218 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4219 m_xTreeView->MakeVisible(pEntry);
4220 enable_notify_events();
4221 }
4222
4223 bool SalInstanceTreeView::is_selected(int pos) const
4224 {
4225 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4226 return m_xTreeView->IsSelected(pEntry);
4227 }
4228
4229 void SalInstanceTreeView::unselect(int pos)
4230 {
4231 assert(m_xTreeView->IsUpdateMode()
4232 && "don't select when frozen, select after thaw. Note selection doesn't survive a "
4233 "freeze");
4234 disable_notify_events();
4235 if (pos == -1)
4236 m_xTreeView->SelectAll(true);
4237 else
4238 {
4239 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4240 m_xTreeView->Select(pEntry, false);
4241 }
4242 enable_notify_events();
4243 }
4244
4245 std::vector<int> SalInstanceTreeView::get_selected_rows() const
4246 {
4247 std::vector<int> aRows;
4248
4249 aRows.reserve(m_xTreeView->GetSelectionCount());
4250 for (SvTreeListEntry* pEntry = m_xTreeView->FirstSelected(); pEntry;
4251 pEntry = m_xTreeView->NextSelected(pEntry))
4252 aRows.push_back(SvTreeList::GetRelPos(pEntry));
4253
4254 return aRows;
4255 }
4256
4257 OUString SalInstanceTreeView::get_text(SvTreeListEntry* pEntry, int col) const
4258 {
4259 if (col == -1)
4260 return SvTabListBox::GetEntryText(pEntry, 0);
4261
4262 col = to_internal_model(col);
4263
4264 if (static_cast<size_t>(col) == pEntry->ItemCount())
4265 return OUString();
4266
4267 assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount());
4268 SvLBoxItem& rItem = pEntry->GetItem(col);
4269 assert(dynamic_cast<SvLBoxString*>(&rItem));
4270 return static_cast<SvLBoxString&>(rItem).GetText();
4271 }
4272
4273 OUString SalInstanceTreeView::get_text(int pos, int col) const
4274 {
4275 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4276 return get_text(pEntry, col);
4277 }
4278
4279 void SalInstanceTreeView::set_text(SvTreeListEntry* pEntry, const OUString& rText, int col)
4280 {
4281 if (col == -1)
4282 {
4283 m_xTreeView->SetEntryText(pEntry, rText);
4284 return;
4285 }
4286
4287 col = to_internal_model(col);
4288
4289 // blank out missing entries
4290 for (int i = pEntry->ItemCount(); i < col; ++i)
4291 AddStringItem(pEntry, "", i - 1);
4292
4293 if (static_cast<size_t>(col) == pEntry->ItemCount())
4294 {
4295 AddStringItem(pEntry, rText, col - 1);
4296 SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pEntry);
4297 m_xTreeView->InitViewData(pViewData, pEntry);
4298 }
4299 else
4300 {
4301 assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount());
4302 SvLBoxItem& rItem = pEntry->GetItem(col);
4303 assert(dynamic_cast<SvLBoxString*>(&rItem));
4304 static_cast<SvLBoxString&>(rItem).SetText(rText);
4305 }
4306
4307 InvalidateModelEntry(pEntry);
4308 }
4309
4310 void SalInstanceTreeView::set_text(int pos, const OUString& rText, int col)
4311 {
4312 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4313 set_text(pEntry, rText, col);
4314 }
4315
4316 void SalInstanceTreeView::set_sensitive(SvTreeListEntry* pEntry, bool bSensitive, int col)
4317 {
4318 if (col == -1)
4319 {
4320 auto nFlags = pEntry->GetFlags() & ~SvTLEntryFlags::SEMITRANSPARENT;
4321 if (!bSensitive)
4322 nFlags = nFlags | SvTLEntryFlags::SEMITRANSPARENT;
4323 pEntry->SetFlags(nFlags);
4324 const sal_uInt16 nCount = pEntry->ItemCount();
4325 for (sal_uInt16 nCur = 0; nCur < nCount; ++nCur)
4326 {
4327 SvLBoxItem& rItem = pEntry->GetItem(nCur);
4328 if (rItem.GetType() == SvLBoxItemType::String
4329 || rItem.GetType() == SvLBoxItemType::Button
4330 || rItem.GetType() == SvLBoxItemType::ContextBmp)
4331 {
4332 rItem.Enable(bSensitive);
4333 InvalidateModelEntry(pEntry);
4334 }
4335 }
4336 return;
4337 }
4338
4339 col = to_internal_model(col);
4340
4341 assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount());
4342 SvLBoxItem& rItem = pEntry->GetItem(col);
4343 rItem.Enable(bSensitive);
4344
4345 InvalidateModelEntry(pEntry);
4346 }
4347
4348 bool SalInstanceTreeView::do_get_sensitive(SvTreeListEntry* pEntry, int col)
4349 {
4350 if (static_cast<size_t>(col) == pEntry->ItemCount())
4351 return false;
4352
4353 assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount());
4354 SvLBoxItem& rItem = pEntry->GetItem(col);
4355 return rItem.isEnable();
4356 }
4357
4358 bool SalInstanceTreeView::get_sensitive(SvTreeListEntry* pEntry, int col) const
4359 {
4360 col = to_internal_model(col);
4361 return do_get_sensitive(pEntry, col);
4362 }
4363
4364 void SalInstanceTreeView::set_sensitive(int pos, bool bSensitive, int col)
4365 {
4366 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4367 set_sensitive(pEntry, bSensitive, col);
4368 }
4369
4370 bool SalInstanceTreeView::get_sensitive(int pos, int col) const
4371 {
4372 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4373 return get_sensitive(pEntry, col);
4374 }
4375
4376 void SalInstanceTreeView::set_sensitive(const weld::TreeIter& rIter, bool bSensitive, int col)
4377 {
4378 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4379 set_sensitive(rVclIter.iter, bSensitive, col);
4380 }
4381
4382 bool SalInstanceTreeView::get_sensitive(const weld::TreeIter& rIter, int col) const
4383 {
4384 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4385 return get_sensitive(rVclIter.iter, col);
4386 }
4387
4388 TriState SalInstanceTreeView::get_toggle(int pos, int col) const
4389 {
4390 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4391 return get_toggle(pEntry, col);
4392 }
4393
4394 TriState SalInstanceTreeView::get_toggle(const weld::TreeIter& rIter, int col) const
4395 {
4396 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4397 return get_toggle(rVclIter.iter, col);
4398 }
4399
4400 void SalInstanceTreeView::enable_toggle_buttons(weld::ColumnToggleType eType)
4401 {
4402 assert(n_children() == 0 && "tree must be empty");
4403 m_bTogglesAsRadio = eType == weld::ColumnToggleType::Radio;
4404
4405 SvLBoxButtonData* pData = m_bTogglesAsRadio ? &m_aRadioButtonData : &m_aCheckButtonData;
4406 m_xTreeView->EnableCheckButton(pData);
4407 // EnableCheckButton clobbered this, restore it
4408 pData->SetLink(LINK(this, SalInstanceTreeView, ToggleHdl));
4409 }
4410
4411 void SalInstanceTreeView::set_toggle(int pos, TriState eState, int col)
4412 {
4413 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4414 set_toggle(pEntry, eState, col);
4415 }
4416
4417 void SalInstanceTreeView::set_toggle(const weld::TreeIter& rIter, TriState eState, int col)
4418 {
4419 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4420 set_toggle(rVclIter.iter, eState, col);
4421 }
4422
4423 void SalInstanceTreeView::set_clicks_to_toggle(int nToggleBehavior)
4424 {
4425 m_xTreeView->SetClicksToToggle(nToggleBehavior);
4426 }
4427
4428 void SalInstanceTreeView::set_extra_row_indent(const weld::TreeIter& rIter, int nIndentLevel)
4429 {
4430 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4431 rVclIter.iter->SetExtraIndent(nIndentLevel);
4432 }
4433
4434 void SalInstanceTreeView::set_text_emphasis(SvTreeListEntry* pEntry, bool bOn, int col)
4435 {
4436 col = to_internal_model(col);
4437
4438 assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount());
4439 SvLBoxItem& rItem = pEntry->GetItem(col);
4440 assert(dynamic_cast<SvLBoxString*>(&rItem));
4441 static_cast<SvLBoxString&>(rItem).Emphasize(bOn);
4442
4443 InvalidateModelEntry(pEntry);
4444 }
4445
4446 void SalInstanceTreeView::set_text_emphasis(const weld::TreeIter& rIter, bool bOn, int col)
4447 {
4448 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4449 set_text_emphasis(rVclIter.iter, bOn, col);
4450 }
4451
4452 void SalInstanceTreeView::set_text_emphasis(int pos, bool bOn, int col)
4453 {
4454 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4455 set_text_emphasis(pEntry, bOn, col);
4456 }
4457
4458 bool SalInstanceTreeView::get_text_emphasis(const weld::TreeIter& rIter, int col) const
4459 {
4460 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4461 return get_text_emphasis(rVclIter.iter, col);
4462 }
4463
4464 bool SalInstanceTreeView::get_text_emphasis(int pos, int col) const
4465 {
4466 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4467 return get_text_emphasis(pEntry, col);
4468 }
4469
4470 void SalInstanceTreeView::set_text_align(SvTreeListEntry* pEntry, double fAlign, int col)
4471 {
4472 col = to_internal_model(col);
4473
4474 assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount());
4475 SvLBoxItem& rItem = pEntry->GetItem(col);
4476 assert(dynamic_cast<SvLBoxString*>(&rItem));
4477 static_cast<SvLBoxString&>(rItem).Align(fAlign);
4478
4479 InvalidateModelEntry(pEntry);
4480 }
4481
4482 void SalInstanceTreeView::set_text_align(const weld::TreeIter& rIter, double fAlign, int col)
4483 {
4484 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4485 set_text_align(rVclIter.iter, fAlign, col);
4486 }
4487
4488 void SalInstanceTreeView::set_text_align(int pos, double fAlign, int col)
4489 {
4490 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4491 set_text_align(pEntry, fAlign, col);
4492 }
4493
4494 void SalInstanceTreeView::connect_editing(const Link<const weld::TreeIter&, bool>& rStartLink,
4495 const Link<const iter_string&, bool>& rEndLink)
4496 {
4497 m_xTreeView->EnableInplaceEditing(rStartLink.IsSet() || rEndLink.IsSet());
4498 weld::TreeView::connect_editing(rStartLink, rEndLink);
4499 }
4500
4501 void SalInstanceTreeView::start_editing(const weld::TreeIter& rIter)
4502 {
4503 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4504 m_xTreeView->EditEntry(rVclIter.iter);
4505 }
4506
4507 void SalInstanceTreeView::end_editing() { m_xTreeView->EndEditing(); }
4508
4509 void SalInstanceTreeView::set_image(SvTreeListEntry* pEntry, const Image& rImage, int col)
4510 {
4511 if (col == -1)
4512 {
4513 m_xTreeView->SetExpandedEntryBmp(pEntry, rImage);
4514 m_xTreeView->SetCollapsedEntryBmp(pEntry, rImage);
4515 return;
4516 }
4517
4518 col = to_internal_model(col);
4519
4520 // blank out missing entries
4521 for (int i = pEntry->ItemCount(); i < col; ++i)
4522 AddStringItem(pEntry, "", i - 1);
4523
4524 if (static_cast<size_t>(col) == pEntry->ItemCount())
4525 {
4526 pEntry->AddItem(std::make_unique<SvLBoxContextBmp>(rImage, rImage, false));
4527 SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pEntry);
4528 m_xTreeView->InitViewData(pViewData, pEntry);
4529 }
4530 else
4531 {
4532 assert(col >= 0 && o3tl::make_unsigned(col) < pEntry->ItemCount());
4533 SvLBoxItem& rItem = pEntry->GetItem(col);
4534 assert(dynamic_cast<SvLBoxContextBmp*>(&rItem));
4535 static_cast<SvLBoxContextBmp&>(rItem).SetBitmap1(rImage);
4536 static_cast<SvLBoxContextBmp&>(rItem).SetBitmap2(rImage);
4537 }
4538
4539 m_xTreeView->CalcEntryHeight(pEntry);
4540 InvalidateModelEntry(pEntry);
4541 }
4542
4543 void SalInstanceTreeView::set_image(int pos, const OUString& rImage, int col)
4544 {
4545 set_image(m_xTreeView->GetEntry(nullptr, pos), createImage(rImage), col);
4546 }
4547
4548 void SalInstanceTreeView::set_image(int pos,
4549 const css::uno::Reference<css::graphic::XGraphic>& rImage,
4550 int col)
4551 {
4552 set_image(m_xTreeView->GetEntry(nullptr, pos), Image(rImage), col);
4553 }
4554
4555 void SalInstanceTreeView::set_image(int pos, VirtualDevice& rImage, int col)
4556 {
4557 set_image(m_xTreeView->GetEntry(nullptr, pos), createImage(rImage), col);
4558 }
4559
4560 void SalInstanceTreeView::set_image(const weld::TreeIter& rIter, const OUString& rImage, int col)
4561 {
4562 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4563 set_image(rVclIter.iter, createImage(rImage), col);
4564 }
4565
4566 void SalInstanceTreeView::set_image(const weld::TreeIter& rIter,
4567 const css::uno::Reference<css::graphic::XGraphic>& rImage,
4568 int col)
4569 {
4570 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4571 set_image(rVclIter.iter, Image(rImage), col);
4572 }
4573
4574 void SalInstanceTreeView::set_image(const weld::TreeIter& rIter, VirtualDevice& rImage, int col)
4575 {
4576 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4577 set_image(rVclIter.iter, createImage(rImage), col);
4578 }
4579
4580 const OUString* SalInstanceTreeView::getEntryData(int index) const
4581 {
4582 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, index);
4583 return pEntry ? static_cast<const OUString*>(pEntry->GetUserData()) : nullptr;
4584 }
4585
4586 OUString SalInstanceTreeView::get_id(int pos) const
4587 {
4588 const OUString* pRet = getEntryData(pos);
4589 if (!pRet)
4590 return OUString();
4591 return *pRet;
4592 }
4593
4594 void SalInstanceTreeView::set_id(SvTreeListEntry* pEntry, const OUString& rId)
4595 {
4596 m_aUserData.emplace_back(std::make_unique<OUString>(rId));
4597 pEntry->SetUserData(m_aUserData.back().get());
4598 }
4599
4600 void SalInstanceTreeView::set_id(int pos, const OUString& rId)
4601 {
4602 SvTreeListEntry* pEntry = m_xTreeView->GetEntry(nullptr, pos);
4603 set_id(pEntry, rId);
4604 }
4605
4606 int SalInstanceTreeView::get_selected_index() const
4607 {
4608 assert(m_xTreeView->IsUpdateMode() && "don't request selection when frozen");
4609 SvTreeListEntry* pEntry = m_xTreeView->FirstSelected();
4610 if (!pEntry)
4611 return -1;
4612 return SvTreeList::GetRelPos(pEntry);
4613 }
4614
4615 OUString SalInstanceTreeView::get_selected_text() const
4616 {
4617 assert(m_xTreeView->IsUpdateMode() && "don't request selection when frozen");
4618 if (SvTreeListEntry* pEntry = m_xTreeView->FirstSelected())
4619 return SvTabListBox::GetEntryText(pEntry, 0);
4620 return OUString();
4621 }
4622
4623 OUString SalInstanceTreeView::get_selected_id() const
4624 {
4625 assert(m_xTreeView->IsUpdateMode() && "don't request selection when frozen");
4626 if (SvTreeListEntry* pEntry = m_xTreeView->FirstSelected())
4627 {
4628 if (const OUString* pStr = static_cast<const OUString*>(pEntry->GetUserData()))
4629 return *pStr;
4630 }
4631 return OUString();
4632 }
4633
4634 std::unique_ptr<weld::TreeIter>
4635 SalInstanceTreeView::make_iterator(const weld::TreeIter* pOrig) const
4636 {
4637 return std::unique_ptr<weld::TreeIter>(
4638 new SalInstanceTreeIter(static_cast<const SalInstanceTreeIter*>(pOrig)));
4639 }
4640
4641 void SalInstanceTreeView::copy_iterator(const weld::TreeIter& rSource, weld::TreeIter& rDest) const
4642 {
4643 const SalInstanceTreeIter& rVclSource(static_cast<const SalInstanceTreeIter&>(rSource));
4644 SalInstanceTreeIter& rVclDest(static_cast<SalInstanceTreeIter&>(rDest));
4645 rVclDest.iter = rVclSource.iter;
4646 }
4647
4648 bool SalInstanceTreeView::get_selected(weld::TreeIter* pIter) const
4649 {
4650 SvTreeListEntry* pEntry = m_xTreeView->FirstSelected();
4651 auto pVclIter = static_cast<SalInstanceTreeIter*>(pIter);
4652 if (pVclIter)
4653 pVclIter->iter = pEntry;
4654 return pEntry != nullptr;
4655 }
4656
4657 bool SalInstanceTreeView::get_cursor(weld::TreeIter* pIter) const
4658 {
4659 SvTreeListEntry* pEntry = m_xTreeView->GetCurEntry();
4660 auto pVclIter = static_cast<SalInstanceTreeIter*>(pIter);
4661 if (pVclIter)
4662 pVclIter->iter = pEntry;
4663 return pEntry != nullptr;
4664 }
4665
4666 void SalInstanceTreeView::set_cursor(const weld::TreeIter& rIter)
4667 {
4668 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4669 disable_notify_events();
4670 m_xTreeView->SetCurEntry(rVclIter.iter);
4671 enable_notify_events();
4672 }
4673
4674 bool SalInstanceTreeView::get_iter_first(weld::TreeIter& rIter) const
4675 {
4676 SalInstanceTreeIter& rVclIter = static_cast<SalInstanceTreeIter&>(rIter);
4677 rVclIter.iter = m_xTreeView->GetEntry(0);
4678 return rVclIter.iter != nullptr;
4679 }
4680
4681 bool SalInstanceTreeView::get_iter_abs_pos(weld::TreeIter& rIter, int nAbsPos) const
4682 {
4683 SalInstanceTreeIter& rVclIter = static_cast<SalInstanceTreeIter&>(rIter);
4684 rVclIter.iter = m_xTreeView->GetEntryAtAbsPos(nAbsPos);
4685 return rVclIter.iter != nullptr;
4686 }
4687
4688 bool SalInstanceTreeView::iter_next_sibling(weld::TreeIter& rIter) const
4689 {
4690 SalInstanceTreeIter& rVclIter = static_cast<SalInstanceTreeIter&>(rIter);
4691 rVclIter.iter = rVclIter.iter->NextSibling();
4692 return rVclIter.iter != nullptr;
4693 }
4694
4695 bool SalInstanceTreeView::iter_previous_sibling(weld::TreeIter& rIter) const
4696 {
4697 SalInstanceTreeIter& rVclIter = static_cast<SalInstanceTreeIter&>(rIter);
4698 rVclIter.iter = rVclIter.iter->PrevSibling();
4699 return rVclIter.iter != nullptr;
4700 }
4701
4702 bool SalInstanceTreeView::iter_next(weld::TreeIter& rIter) const
4703 {
4704 SalInstanceTreeIter& rVclIter = static_cast<SalInstanceTreeIter&>(rIter);
4705 rVclIter.iter = m_xTreeView->Next(rVclIter.iter);
4706 if (rVclIter.iter && IsDummyEntry(rVclIter.iter))
4707 return iter_next(rVclIter);
4708 return rVclIter.iter != nullptr;
4709 }
4710
4711 bool SalInstanceTreeView::iter_previous(weld::TreeIter& rIter) const
4712 {
4713 SalInstanceTreeIter& rVclIter = static_cast<SalInstanceTreeIter&>(rIter);
4714 rVclIter.iter = m_xTreeView->Prev(rVclIter.iter);
4715 if (rVclIter.iter && IsDummyEntry(rVclIter.iter))
4716 return iter_previous(rVclIter);
4717 return rVclIter.iter != nullptr;
4718 }
4719
4720 bool SalInstanceTreeView::iter_children(weld::TreeIter& rIter) const
4721 {
4722 SalInstanceTreeIter& rVclIter = static_cast<SalInstanceTreeIter&>(rIter);
4723 rVclIter.iter = m_xTreeView->FirstChild(rVclIter.iter);
4724 bool bRet = rVclIter.iter != nullptr;
4725 if (bRet)
4726 {
4727 //on-demand dummy entry doesn't count
4728 return !IsDummyEntry(rVclIter.iter);
4729 }
4730 return bRet;
4731 }
4732
4733 bool SalInstanceTreeView::iter_parent(weld::TreeIter& rIter) const
4734 {
4735 SalInstanceTreeIter& rVclIter = static_cast<SalInstanceTreeIter&>(rIter);
4736 rVclIter.iter = m_xTreeView->GetParent(rVclIter.iter);
4737 return rVclIter.iter != nullptr;
4738 }
4739
4740 void SalInstanceTreeView::remove(const weld::TreeIter& rIter)
4741 {
4742 disable_notify_events();
4743 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4744 m_xTreeView->RemoveEntry(rVclIter.iter);
4745 enable_notify_events();
4746 }
4747
4748 void SalInstanceTreeView::select(const weld::TreeIter& rIter)
4749 {
4750 assert(m_xTreeView->IsUpdateMode()
4751 && "don't select when frozen, select after thaw. Note selection doesn't survive a "
4752 "freeze");
4753 disable_notify_events();
4754 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4755 m_xTreeView->Select(rVclIter.iter, true);
4756 enable_notify_events();
4757 }
4758
4759 void SalInstanceTreeView::scroll_to_row(const weld::TreeIter& rIter)
4760 {
4761 assert(m_xTreeView->IsUpdateMode()
4762 && "don't select when frozen, select after thaw. Note selection doesn't survive a "
4763 "freeze");
4764 disable_notify_events();
4765 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4766 m_xTreeView->MakeVisible(rVclIter.iter);
4767 enable_notify_events();
4768 }
4769
4770 void SalInstanceTreeView::unselect(const weld::TreeIter& rIter)
4771 {
4772 assert(m_xTreeView->IsUpdateMode() && "don't unselect when frozen");
4773 disable_notify_events();
4774 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4775 m_xTreeView->Select(rVclIter.iter, false);
4776 enable_notify_events();
4777 }
4778
4779 int SalInstanceTreeView::get_iter_depth(const weld::TreeIter& rIter) const
4780 {
4781 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4782 return m_xTreeView->GetModel()->GetDepth(rVclIter.iter);
4783 }
4784
4785 bool SalInstanceTreeView::iter_has_child(const weld::TreeIter& rIter) const
4786 {
4787 SalInstanceTreeIter aTempCopy(static_cast<const SalInstanceTreeIter*>(&rIter));
4788 return iter_children(aTempCopy);
4789 }
4790
4791 bool SalInstanceTreeView::get_row_expanded(const weld::TreeIter& rIter) const
4792 {
4793 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4794 return m_xTreeView->IsExpanded(rVclIter.iter);
4795 }
4796
4797 bool SalInstanceTreeView::get_children_on_demand(const weld::TreeIter& rIter) const
4798 {
4799 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4800 if (m_aExpandingPlaceHolderParents.count(rVclIter.iter))
4801 return true;
4802 return GetPlaceHolderChild(rVclIter.iter) != nullptr;
4803 }
4804
4805 void SalInstanceTreeView::set_children_on_demand(const weld::TreeIter& rIter,
4806 bool bChildrenOnDemand)
4807 {
4808 disable_notify_events();
4809
4810 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4811
4812 SvTreeListEntry* pPlaceHolder = GetPlaceHolderChild(rVclIter.iter);
4813
4814 if (bChildrenOnDemand && !pPlaceHolder)
4815 {
4816 pPlaceHolder = m_xTreeView->InsertEntry("<dummy>", rVclIter.iter, false, 0, nullptr);
4817 SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pPlaceHolder);
4818 pViewData->SetSelectable(false);
4819 }
4820 else if (!bChildrenOnDemand && pPlaceHolder)
4821 m_xTreeView->RemoveEntry(pPlaceHolder);
4822
4823 enable_notify_events();
4824 }
4825
4826 void SalInstanceTreeView::expand_row(const weld::TreeIter& rIter)
4827 {
4828 assert(m_xTreeView->IsUpdateMode() && "don't expand when frozen");
4829 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4830 if (!m_xTreeView->IsExpanded(rVclIter.iter) && ExpandRow(rVclIter))
4831 m_xTreeView->Expand(rVclIter.iter);
4832 }
4833
4834 void SalInstanceTreeView::collapse_row(const weld::TreeIter& rIter)
4835 {
4836 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4837 if (m_xTreeView->IsExpanded(rVclIter.iter) && signal_collapsing(rIter))
4838 m_xTreeView->Collapse(rVclIter.iter);
4839 }
4840
4841 OUString SalInstanceTreeView::get_text(const weld::TreeIter& rIter, int col) const
4842 {
4843 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4844 return get_text(rVclIter.iter, col);
4845 }
4846
4847 void SalInstanceTreeView::set_text(const weld::TreeIter& rIter, const OUString& rText, int col)
4848 {
4849 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4850 set_text(rVclIter.iter, rText, col);
4851 }
4852
4853 OUString SalInstanceTreeView::get_id(const weld::TreeIter& rIter) const
4854 {
4855 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4856 const OUString* pStr = static_cast<const OUString*>(rVclIter.iter->GetUserData());
4857 if (pStr)
4858 return *pStr;
4859 return OUString();
4860 }
4861
4862 void SalInstanceTreeView::set_id(const weld::TreeIter& rIter, const OUString& rId)
4863 {
4864 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4865 set_id(rVclIter.iter, rId);
4866 }
4867
4868 void SalInstanceTreeView::enable_drag_source(rtl::Reference<TransferDataContainer>& rHelper,
4869 sal_uInt8 eDNDConstants)
4870 {
4871 m_xTreeView->SetDragHelper(rHelper, eDNDConstants);
4872 }
4873
4874 void SalInstanceTreeView::set_selection_mode(SelectionMode eMode)
4875 {
4876 m_xTreeView->SetSelectionMode(eMode);
4877 }
4878
4879 void SalInstanceTreeView::all_foreach(const std::function<bool(weld::TreeIter&)>& func)
4880 {
4881 UpdateGuardIfHidden aGuard(*m_xTreeView);
4882
4883 SalInstanceTreeIter aVclIter(m_xTreeView->First());
4884 while (aVclIter.iter)
4885 {
4886 if (func(aVclIter))
4887 return;
4888 iter_next(aVclIter);
4889 }
4890 }
4891
4892 void SalInstanceTreeView::selected_foreach(const std::function<bool(weld::TreeIter&)>& func)
4893 {
4894 UpdateGuardIfHidden aGuard(*m_xTreeView);
4895
4896 SalInstanceTreeIter aVclIter(m_xTreeView->FirstSelected());
4897 while (aVclIter.iter)
4898 {
4899 if (func(aVclIter))
4900 return;
4901 aVclIter.iter = m_xTreeView->NextSelected(aVclIter.iter);
4902 }
4903 }
4904
4905 void SalInstanceTreeView::visible_foreach(const std::function<bool(weld::TreeIter&)>& func)
4906 {
4907 UpdateGuardIfHidden aGuard(*m_xTreeView);
4908
4909 SalInstanceTreeIter aVclIter(m_xTreeView->GetFirstEntryInView());
4910 while (aVclIter.iter)
4911 {
4912 if (func(aVclIter))
4913 return;
4914 aVclIter.iter = m_xTreeView->GetNextEntryInView(aVclIter.iter);
4915 }
4916 }
4917
4918 void SalInstanceTreeView::connect_visible_range_changed(const Link<weld::TreeView&, void>& rLink)
4919 {
4920 weld::TreeView::connect_visible_range_changed(rLink);
4921 m_xTreeView->SetScrolledHdl(LINK(this, SalInstanceTreeView, VisibleRangeChangedHdl));
4922 }
4923
4924 void SalInstanceTreeView::remove_selection()
4925 {
4926 disable_notify_events();
4927 SvTreeListEntry* pSelected = m_xTreeView->FirstSelected();
4928 while (pSelected)
4929 {
4930 SvTreeListEntry* pNextSelected = m_xTreeView->NextSelected(pSelected);
4931 m_xTreeView->RemoveEntry(pSelected);
4932 pSelected = pNextSelected;
4933 }
4934 enable_notify_events();
4935 }
4936
4937 bool SalInstanceTreeView::is_selected(const weld::TreeIter& rIter) const
4938 {
4939 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4940 return m_xTreeView->IsSelected(rVclIter.iter);
4941 }
4942
4943 int SalInstanceTreeView::get_iter_index_in_parent(const weld::TreeIter& rIter) const
4944 {
4945 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
4946 return SvTreeList::GetRelPos(rVclIter.iter);
4947 }
4948
4949 int SalInstanceTreeView::iter_compare(const weld::TreeIter& a, const weld::TreeIter& b) const
4950 {
4951 const SalInstanceTreeIter& rVclIterA = static_cast<const SalInstanceTreeIter&>(a);
4952 const SalInstanceTreeIter& rVclIterB = static_cast<const SalInstanceTreeIter&>(b);
4953 const SvTreeList* pModel = m_xTreeView->GetModel();
4954 auto nAbsPosA = pModel->GetAbsPos(rVclIterA.iter);
4955 auto nAbsPosB = pModel->GetAbsPos(rVclIterB.iter);
4956 if (nAbsPosA < nAbsPosB)
4957 return -1;
4958 if (nAbsPosA > nAbsPosB)
4959 return 1;
4960 return 0;
4961 }
4962
4963 void SalInstanceTreeView::move_subtree(weld::TreeIter& rNode, const weld::TreeIter* pNewParent,
4964 int nIndexInNewParent)
4965 {
4966 SalInstanceTreeIter& rVclIter = static_cast<SalInstanceTreeIter&>(rNode);
4967 const SalInstanceTreeIter* pVclParentIter = static_cast<const SalInstanceTreeIter*>(pNewParent);
4968 m_xTreeView->GetModel()->Move(rVclIter.iter, pVclParentIter ? pVclParentIter->iter : nullptr,
4969 nIndexInNewParent);
4970 }
4971
4972 int SalInstanceTreeView::count_selected_rows() const { return m_xTreeView->GetSelectionCount(); }
4973
4974 int SalInstanceTreeView::get_height_rows(int nRows) const
4975 {
4976 int nHeight = m_xTreeView->GetEntryHeight() * nRows;
4977
4978 sal_Int32 nLeftBorder(0), nTopBorder(0), nRightBorder(0), nBottomBorder(0);
4979 m_xTreeView->GetBorder(nLeftBorder, nTopBorder, nRightBorder, nBottomBorder);
4980 nHeight += nTopBorder + nBottomBorder;
4981
4982 return nHeight;
4983 }
4984
4985 void SalInstanceTreeView::make_sorted()
4986 {
4987 assert(m_xTreeView->IsUpdateMode() && "don't sort when frozen");
4988 m_xTreeView->SetStyle(m_xTreeView->GetStyle() | WB_SORT);
4989 m_xTreeView->GetModel()->SetCompareHdl(LINK(this, SalInstanceTreeView, CompareHdl));
4990 set_sort_order(true);
4991 }
4992
4993 void SalInstanceTreeView::set_sort_func(
4994 const std::function<int(const weld::TreeIter&, const weld::TreeIter&)>& func)
4995 {
4996 weld::TreeView::set_sort_func(func);
4997 SvTreeList* pListModel = m_xTreeView->GetModel();
4998 pListModel->Resort();
4999 }
5000
5001 void SalInstanceTreeView::make_unsorted()
5002 {
5003 m_xTreeView->SetStyle(m_xTreeView->GetStyle() & ~WB_SORT);
5004 }
5005
5006 void SalInstanceTreeView::set_sort_order(bool bAscending)
5007 {
5008 SvTreeList* pListModel = m_xTreeView->GetModel();
5009 pListModel->SetSortMode(bAscending ? SvSortMode::Ascending : SvSortMode::Descending);
5010 pListModel->Resort();
5011 }
5012
5013 bool SalInstanceTreeView::get_sort_order() const
5014 {
5015 return m_xTreeView->GetModel()->GetSortMode() == SvSortMode::Ascending;
5016 }
5017
5018 void SalInstanceTreeView::set_sort_indicator(TriState eState, int col)
5019 {
5020 assert(col >= 0 && "cannot sort on expander column");
5021
5022 LclHeaderTabListBox* pHeaderBox = dynamic_cast<LclHeaderTabListBox*>(m_xTreeView.get());
5023 HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr;
5024 if (!pHeaderBar)
5025 return;
5026
5027 sal_uInt16 nTextId = pHeaderBar->GetItemId(col);
5028 HeaderBarItemBits nBits = pHeaderBar->GetItemBits(nTextId);
5029 nBits &= ~HeaderBarItemBits::UPARROW;
5030 nBits &= ~HeaderBarItemBits::DOWNARROW;
5031 if (eState != TRISTATE_INDET)
5032 {
5033 if (eState == TRISTATE_TRUE)
5034 nBits |= HeaderBarItemBits::DOWNARROW;
5035 else
5036 nBits |= HeaderBarItemBits::UPARROW;
5037 }
5038 pHeaderBar->SetItemBits(nTextId, nBits);
5039 }
5040
5041 TriState SalInstanceTreeView::get_sort_indicator(int col) const
5042 {
5043 assert(col >= 0 && "cannot sort on expander column");
5044
5045 LclHeaderTabListBox* pHeaderBox = dynamic_cast<LclHeaderTabListBox*>(m_xTreeView.get());
5046 if (HeaderBar* pHeaderBar = pHeaderBox ? pHeaderBox->GetHeaderBar() : nullptr)
5047 {
5048 sal_uInt16 nTextId = pHeaderBar->GetItemId(col);
5049 HeaderBarItemBits nBits = pHeaderBar->GetItemBits(nTextId);
5050 if (nBits & HeaderBarItemBits::DOWNARROW)
5051 return TRISTATE_TRUE;
5052 if (nBits & HeaderBarItemBits::UPARROW)
5053 return TRISTATE_FALSE;
5054 }
5055
5056 return TRISTATE_INDET;
5057 }
5058
5059 int SalInstanceTreeView::get_sort_column() const { return m_nSortColumn; }
5060
5061 void SalInstanceTreeView::set_sort_column(int nColumn)
5062 {
5063 if (nColumn == -1)
5064 {
5065 make_unsorted();
5066 m_nSortColumn = -1;
5067 return;
5068 }
5069
5070 if (nColumn != m_nSortColumn)
5071 {
5072 m_nSortColumn = nColumn;
5073 m_xTreeView->GetModel()->Resort();
5074 }
5075 }
5076
5077 SvTabListBox& SalInstanceTreeView::getTreeView() { return *m_xTreeView; }
5078
5079 bool SalInstanceTreeView::get_dest_row_at_pos(const Point& rPos, weld::TreeIter* pResult,
5080 bool bDnDMode, bool bAutoScroll)
5081 {
5082 LclTabListBox* pTreeView
5083 = !bDnDMode ? dynamic_cast<LclTabListBox*>(m_xTreeView.get()) : nullptr;
5084 SvTreeListEntry* pTarget = pTreeView ? pTreeView->GetTargetAtPoint(rPos, false, bAutoScroll)
5085 : m_xTreeView->GetDropTarget(rPos);
5086
5087 if (pTarget && pResult)
5088 {
5089 SalInstanceTreeIter& rSalIter = static_cast<SalInstanceTreeIter&>(*pResult);
5090 rSalIter.iter = pTarget;
5091 }
5092
5093 return pTarget != nullptr;
5094 }
5095
5096 void SalInstanceTreeView::unset_drag_dest_row() { m_xTreeView->UnsetDropTarget(); }
5097
5098 tools::Rectangle SalInstanceTreeView::get_row_area(const weld::TreeIter& rIter) const
5099 {
5100 return m_xTreeView->GetBoundingRect(static_cast<const SalInstanceTreeIter&>(rIter).iter);
5101 }
5102
5103 weld::TreeView* SalInstanceTreeView::get_drag_source() const { return g_DragSource; }
5104
5105 int SalInstanceTreeView::vadjustment_get_value() const
5106 {
5107 int nValue = -1;
5108 const SvTreeListEntry* pEntry = m_xTreeView->GetFirstEntryInView();
5109 if (pEntry)
5110 nValue = m_xTreeView->GetAbsPos(pEntry);
5111 return nValue;
5112 }
5113
5114 void SalInstanceTreeView::vadjustment_set_value(int nValue)
5115 {
5116 if (nValue == -1)
5117 return;
5118 bool bUpdate = m_xTreeView->IsUpdateMode();
5119 if (bUpdate)
5120 m_xTreeView->SetUpdateMode(false);
5121 m_xTreeView->ScrollToAbsPos(nValue);
5122 if (bUpdate)
5123 m_xTreeView->SetUpdateMode(true);
5124 }
5125
5126 void SalInstanceTreeView::set_show_expanders(bool bShow)
5127 {
5128 m_xTreeView->set_property("show-expanders", OUString::boolean(bShow));
5129 }
5130
5131 bool SalInstanceTreeView::changed_by_hover() const { return m_xTreeView->IsSelectDueToHover(); }
5132
5133 SalInstanceTreeView::~SalInstanceTreeView()
5134 {
5135 LclHeaderTabListBox* pHeaderBox = dynamic_cast<LclHeaderTabListBox*>(m_xTreeView.get());
5136 if (pHeaderBox)
5137 {
5138 if (HeaderBar* pHeaderBar = pHeaderBox->GetHeaderBar())
5139 {
5140 pHeaderBar->SetSelectHdl(Link<HeaderBar*, void>());
5141 pHeaderBar->SetEndDragHdl(Link<HeaderBar*, void>());
5142 }
5143 }
5144 else
5145 {
5146 static_cast<LclTabListBox&>(*m_xTreeView).SetEndDragHdl(Link<SvTreeListBox*, void>());
5147 static_cast<LclTabListBox&>(*m_xTreeView).SetStartDragHdl(Link<SvTreeListBox*, bool>());
5148 static_cast<LclTabListBox&>(*m_xTreeView).SetModelChangedHdl(Link<SvTreeListBox*, void>());
5149 }
5150 if (g_DragSource == this)
5151 g_DragSource = nullptr;
5152 m_xTreeView->SetPopupMenuHdl(Link<const CommandEvent&, bool>());
5153 m_xTreeView->SetExpandingHdl(Link<SvTreeListBox*, bool>());
5154 m_xTreeView->SetDoubleClickHdl(Link<SvTreeListBox*, bool>());
5155 m_xTreeView->SetSelectHdl(Link<SvTreeListBox*, void>());
5156 m_xTreeView->SetDeselectHdl(Link<SvTreeListBox*, void>());
5157 m_xTreeView->SetScrolledHdl(Link<SvTreeListBox*, void>());
5158 m_xTreeView->SetTooltipHdl({});
5159 m_xTreeView->SetCustomRenderHdl(Link<svtree_render_args, void>());
5160 m_xTreeView->SetCustomMeasureHdl(Link<svtree_measure_args, Size>());
5161 }
5162
5163 IMPL_LINK(SalInstanceTreeView, TooltipHdl, SvTreeListEntry*, pEntry, OUString)
5164 {
5165 if (pEntry && !notify_events_disabled())
5166 return signal_query_tooltip(SalInstanceTreeIter(pEntry));
5167
5168 return {};
5169 }
5170
5171 IMPL_LINK(SalInstanceTreeView, CustomRenderHdl, svtree_render_args, payload, void)
5172 {
5173 vcl::RenderContext& rRenderDevice = std::get<0>(payload);
5174 const tools::Rectangle& rRect = std::get<1>(payload);
5175 const SvTreeListEntry& rEntry = std::get<2>(payload);
5176 const OUString* pId = static_cast<const OUString*>(rEntry.GetUserData());
5177 if (!pId)
5178 return;
5179 signal_custom_render(rRenderDevice, rRect, m_xTreeView->IsSelected(&rEntry), *pId);
5180 }
5181
5182 IMPL_LINK(SalInstanceTreeView, CustomMeasureHdl, svtree_measure_args, payload, Size)
5183 {
5184 vcl::RenderContext& rRenderDevice = payload.first;
5185 const SvTreeListEntry& rEntry = payload.second;
5186 const OUString* pId = static_cast<const OUString*>(rEntry.GetUserData());
5187 if (!pId)
5188 return Size();
5189 return signal_custom_get_size(rRenderDevice, *pId);
5190 }
5191
5192 IMPL_LINK(SalInstanceTreeView, CompareHdl, const SvSortData&, rSortData, sal_Int32)
5193 {
5194 const SvTreeListEntry* pLHS = rSortData.pLeft;
5195 const SvTreeListEntry* pRHS = rSortData.pRight;
5196 assert(pLHS && pRHS);
5197
5198 if (m_aCustomSort)
5199 return m_aCustomSort(SalInstanceTreeIter(const_cast<SvTreeListEntry*>(pLHS)),
5200 SalInstanceTreeIter(const_cast<SvTreeListEntry*>(pRHS)));
5201
5202 const SvLBoxString* pLeftTextItem;
5203 const SvLBoxString* pRightTextItem;
5204
5205 if (m_nSortColumn != -1)
5206 {
5207 size_t col = to_internal_model(m_nSortColumn);
5208
5209 if (col < pLHS->ItemCount())
5210 {
5211 const SvLBoxString& rLeftTextItem
5212 = static_cast<const SvLBoxString&>(pLHS->GetItem(col));
5213 pLeftTextItem = &rLeftTextItem;
5214 }
5215 else
5216 pLeftTextItem = nullptr;
5217 if (col < pRHS->ItemCount())
5218 {
5219 const SvLBoxString& rRightTextItem
5220 = static_cast<const SvLBoxString&>(pRHS->GetItem(col));
5221 pRightTextItem = &rRightTextItem;
5222 }
5223 else
5224 pRightTextItem = nullptr;
5225 }
5226 else
5227 {
5228 pLeftTextItem
5229 = static_cast<const SvLBoxString*>(pLHS->GetFirstItem(SvLBoxItemType::String));
5230 pRightTextItem
5231 = static_cast<const SvLBoxString*>(pRHS->GetFirstItem(SvLBoxItemType::String));
5232 }
5233
5234 return m_xTreeView->DefaultCompare(pLeftTextItem, pRightTextItem);
5235 }
5236
5237 IMPL_LINK_NOARG(SalInstanceTreeView, VisibleRangeChangedHdl, SvTreeListBox*, void)
5238 {
5239 if (notify_events_disabled())
5240 return;
5241 signal_visible_range_changed();
5242 }
5243
5244 IMPL_LINK_NOARG(SalInstanceTreeView, ModelChangedHdl, SvTreeListBox*, void)
5245 {
5246 if (notify_events_disabled())
5247 return;
5248 signal_model_changed();
5249 }
5250
5251 IMPL_LINK_NOARG(SalInstanceTreeView, StartDragHdl, SvTreeListBox*, bool)
5252 {
5253 bool bUnsetDragIcon(false); // ignored for vcl
5254 if (m_aDragBeginHdl.Call(bUnsetDragIcon))
5255 return true;
5256 g_DragSource = this;
5257 return false;
5258 }
5259
5260 IMPL_STATIC_LINK_NOARG(SalInstanceTreeView, FinishDragHdl, SvTreeListBox*, void)
5261 {
5262 g_DragSource = nullptr;
5263 }
5264
5265 IMPL_LINK(SalInstanceTreeView, ToggleHdl, SvLBoxButtonData*, pData, void)
5266 {
5267 SvTreeListEntry* pEntry = pData->GetActEntry();
5268 SvLBoxButton* pBox = pData->GetActBox();
5269
5270 // tdf#122874 Select the row, calling SelectHdl, before handling
5271 // the toggle
5272 if (!m_xTreeView->IsSelected(pEntry))
5273 {
5274 m_xTreeView->SelectAll(false);
5275 m_xTreeView->Select(pEntry, true);
5276 }
5277
5278 // additionally set the cursor into the row the toggled element is in
5279 m_xTreeView->pImpl->m_pCursor = pEntry;
5280
5281 for (int i = 0, nCount = pEntry->ItemCount(); i < nCount; ++i)
5282 {
5283 SvLBoxItem& rItem = pEntry->GetItem(i);
5284 if (&rItem == pBox)
5285 {
5286 int nCol = to_external_model(i);
5287 signal_toggled(iter_col(SalInstanceTreeIter(pEntry), nCol));
5288 break;
5289 }
5290 }
5291 }
5292
5293 IMPL_LINK_NOARG(SalInstanceTreeView, SelectHdl, SvTreeListBox*, void)
5294 {
5295 if (notify_events_disabled())
5296 return;
5297 signal_changed();
5298 }
5299
5300 IMPL_LINK_NOARG(SalInstanceTreeView, DeSelectHdl, SvTreeListBox*, void)
5301 {
5302 if (notify_events_disabled())
5303 return;
5304 if (m_xTreeView->GetSelectionMode() == SelectionMode::Single
5305 && !m_xTreeView->GetHoverSelection())
5306 return;
5307 signal_changed();
5308 }
5309
5310 IMPL_LINK_NOARG(SalInstanceTreeView, DoubleClickHdl, SvTreeListBox*, bool)
5311 {
5312 if (notify_events_disabled())
5313 return false;
5314 return !signal_row_activated();
5315 }
5316
5317 IMPL_LINK(SalInstanceTreeView, EndDragHdl, HeaderBar*, pHeaderBar, void)
5318 {
5319 std::vector<tools::Long> aTabPositions{ 0 };
5320 for (int i = 0; i < pHeaderBar->GetItemCount() - 1; ++i)
5321 aTabPositions.push_back(aTabPositions[i]
5322 + pHeaderBar->GetItemSize(pHeaderBar->GetItemId(i)));
5323 m_xTreeView->SetTabs(aTabPositions.size(), aTabPositions.data(), MapUnit::MapPixel);
5324 }
5325
5326 IMPL_LINK(SalInstanceTreeView, HeaderBarClickedHdl, HeaderBar*, pHeaderBar, void)
5327 {
5328 sal_uInt16 nId = pHeaderBar->GetCurItemId();
5329 if (!(pHeaderBar->GetItemBits(nId) & HeaderBarItemBits::CLICKABLE))
5330 return;
5331 signal_column_clicked(pHeaderBar->GetItemPos(nId));
5332 }
5333
5334 IMPL_LINK_NOARG(SalInstanceTreeView, ExpandingHdl, SvTreeListBox*, bool)
5335 {
5336 SvTreeListEntry* pEntry = m_xTreeView->GetHdlEntry();
5337 SalInstanceTreeIter aIter(pEntry);
5338
5339 if (m_xTreeView->IsExpanded(pEntry))
5340 {
5341 //collapsing;
5342 return signal_collapsing(aIter);
5343 }
5344
5345 // expanding
5346 return ExpandRow(aIter);
5347 }
5348
5349 bool SalInstanceTreeView::ExpandRow(const SalInstanceTreeIter& rIter)
5350 {
5351 SvTreeListEntry* pEntry = rIter.iter;
5352 // if there's a preexisting placeholder child, required to make this
5353 // potentially expandable in the first place, now we remove it
5354 SvTreeListEntry* pPlaceHolder = GetPlaceHolderChild(pEntry);
5355 if (pPlaceHolder)
5356 {
5357 m_aExpandingPlaceHolderParents.insert(pEntry);
5358 m_xTreeView->RemoveEntry(pPlaceHolder);
5359 }
5360
5361 bool bRet = signal_expanding(rIter);
5362
5363 if (pPlaceHolder)
5364 {
5365 //expand disallowed, restore placeholder
5366 if (!bRet)
5367 {
5368 pPlaceHolder = m_xTreeView->InsertEntry("<dummy>", pEntry, false, 0, nullptr);
5369 SvViewDataEntry* pViewData = m_xTreeView->GetViewDataEntry(pPlaceHolder);
5370 pViewData->SetSelectable(false);
5371 }
5372 m_aExpandingPlaceHolderParents.erase(pEntry);
5373 }
5374
5375 return bRet;
5376 }
5377
5378 IMPL_LINK(SalInstanceTreeView, PopupMenuHdl, const CommandEvent&, rEvent, bool)
5379 {
5380 return m_aPopupMenuHdl.Call(rEvent);
5381 }
5382
5383 IMPL_LINK(SalInstanceTreeView, EditingEntryHdl, SvTreeListEntry*, pEntry, bool)
5384 {
5385 return signal_editing_started(SalInstanceTreeIter(pEntry));
5386 }
5387
5388 IMPL_LINK(SalInstanceTreeView, EditedEntryHdl, IterString, rIterString, bool)
5389 {
5390 return signal_editing_done(
5391 iter_string(SalInstanceTreeIter(rIterString.first), rIterString.second));
5392 }
5393
5394 SalInstanceIconView::SalInstanceIconView(::IconView* pIconView, SalInstanceBuilder* pBuilder,
5395 bool bTakeOwnership)
5396 : SalInstanceWidget(pIconView, pBuilder, bTakeOwnership)
5397 , m_xIconView(pIconView)
5398 {
5399 m_xIconView->SetSelectHdl(LINK(this, SalInstanceIconView, SelectHdl));
5400 m_xIconView->SetDeselectHdl(LINK(this, SalInstanceIconView, DeSelectHdl));
5401 m_xIconView->SetDoubleClickHdl(LINK(this, SalInstanceIconView, DoubleClickHdl));
5402 m_xIconView->SetPopupMenuHdl(LINK(this, SalInstanceIconView, CommandHdl));
5403
5404 m_xIconView->SetEntryAccessibleDescriptionHdl(
5405 LINK(this, SalInstanceIconView, EntryAccessibleDescriptionHdl));
5406 m_xIconView->SetAccessible(m_xIconView->CreateAccessible());
5407 }
5408
5409 int SalInstanceIconView::get_item_width() const { return m_xIconView->GetEntryWidth(); }
5410 void SalInstanceIconView::set_item_width(int width)
5411 {
5412 m_xIconView->SetEntryWidth(width);
5413 m_xIconView->Resize();
5414 }
5415
5416 void SalInstanceIconView::freeze()
5417 {
5418 bool bIsFirstFreeze = IsFirstFreeze();
5419 SalInstanceWidget::freeze();
5420 if (bIsFirstFreeze)
5421 m_xIconView->SetUpdateMode(false);
5422 }
5423
5424 void SalInstanceIconView::thaw()
5425 {
5426 bool bIsLastThaw = IsLastThaw();
5427 if (bIsLastThaw)
5428 m_xIconView->SetUpdateMode(true);
5429 SalInstanceWidget::thaw();
5430 }
5431
5432 void SalInstanceIconView::insert(int pos, const OUString* pStr, const OUString* pId,
5433 const OUString* pIconName, weld::TreeIter* pRet)
5434 {
5435 disable_notify_events();
5436 auto nInsertPos = pos == -1 ? TREELIST_APPEND : pos;
5437 void* pUserData;
5438 if (pId)
5439 {
5440 m_aUserData.emplace_back(std::make_unique<OUString>(*pId));
5441 pUserData = m_aUserData.back().get();
5442 }
5443 else
5444 pUserData = nullptr;
5445
5446 SvTreeListEntry* pEntry = new SvTreeListEntry;
5447 if (pIconName)
5448 {
5449 Image aImage(createImage(*pIconName));
5450 pEntry->AddItem(std::make_unique<SvLBoxContextBmp>(aImage, aImage, false));
5451 }
5452 else
5453 {
5454 Image aDummy;
5455 pEntry->AddItem(std::make_unique<SvLBoxContextBmp>(aDummy, aDummy, false));
5456 }
5457 if (pStr)
5458 pEntry->AddItem(std::make_unique<SvLBoxString>(*pStr));
5459 pEntry->SetUserData(pUserData);
5460 m_xIconView->Insert(pEntry, nullptr, nInsertPos);
5461
5462 if (pRet)
5463 {
5464 SalInstanceTreeIter* pVclRetIter = static_cast<SalInstanceTreeIter*>(pRet);
5465 pVclRetIter->iter = pEntry;
5466 }
5467
5468 enable_notify_events();
5469 }
5470
5471 void SalInstanceIconView::insert(int pos, const OUString* pStr, const OUString* pId,
5472 const VirtualDevice* pIcon, weld::TreeIter* pRet)
5473 {
5474 disable_notify_events();
5475 auto nInsertPos = pos == -1 ? TREELIST_APPEND : pos;
5476 void* pUserData;
5477 if (pId)
5478 {
5479 m_aUserData.emplace_back(std::make_unique<OUString>(*pId));
5480 pUserData = m_aUserData.back().get();
5481 }
5482 else
5483 pUserData = nullptr;
5484
5485 SvTreeListEntry* pEntry = new SvTreeListEntry;
5486 if (pIcon)
5487 {
5488 const Point aNull(0, 0);
5489 const Size aSize = pIcon->GetOutputSize();
5490 Image aImage(pIcon->GetBitmapEx(aNull, aSize));
5491 pEntry->AddItem(std::make_unique<SvLBoxContextBmp>(aImage, aImage, false));
5492 }
5493 else
5494 {
5495 Image aDummy;
5496 pEntry->AddItem(std::make_unique<SvLBoxContextBmp>(aDummy, aDummy, false));
5497 }
5498 if (pStr)
5499 pEntry->AddItem(std::make_unique<SvLBoxString>(*pStr));
5500 pEntry->SetUserData(pUserData);
5501 m_xIconView->Insert(pEntry, nullptr, nInsertPos);
5502
5503 if (pRet)
5504 {
5505 SalInstanceTreeIter* pVclRetIter = static_cast<SalInstanceTreeIter*>(pRet);
5506 pVclRetIter->iter = pEntry;
5507 }
5508
5509 enable_notify_events();
5510 }
5511
5512 void SalInstanceIconView::insert_separator(int pos, const OUString* /* pId */)
5513 {
5514 const auto nInsertPos = pos == -1 ? TREELIST_APPEND : pos;
5515 const OUString sSep(VclResId(STR_SEPARATOR));
5516 SvTreeListEntry* pEntry = new SvTreeListEntry;
5517 pEntry->SetFlags(pEntry->GetFlags() | SvTLEntryFlags::IS_SEPARATOR);
5518 const Image aDummy;
5519 pEntry->AddItem(std::make_unique<SvLBoxContextBmp>(aDummy, aDummy, false));
5520 pEntry->AddItem(std::make_unique<SvLBoxString>(sSep));
5521 pEntry->SetUserData(nullptr);
5522 m_xIconView->Insert(pEntry, nullptr, nInsertPos);
5523 SvViewDataEntry* pViewData = m_xIconView->GetViewDataEntry(pEntry);
5524 pViewData->SetSelectable(false);
5525 }
5526
5527 IMPL_LINK(SalInstanceIconView, TooltipHdl, SvTreeListEntry*, pEntry, OUString)
5528 {
5529 if (pEntry && !notify_events_disabled())
5530 return signal_query_tooltip(SalInstanceTreeIter(pEntry));
5531
5532 return {};
5533 }
5534
5535 IMPL_LINK(SalInstanceIconView, EntryAccessibleDescriptionHdl, SvTreeListEntry*, pEntry, OUString)
5536 {
5537 OUString s = SvTreeListBox::SearchEntryTextWithHeadTitle(pEntry);
5538 if (s.isEmpty())
5539 s = signal_query_tooltip(SalInstanceTreeIter(pEntry));
5540 return s;
5541 }
5542
5543 void SalInstanceIconView::connect_query_tooltip(const Link<const weld::TreeIter&, OUString>& rLink)
5544 {
5545 weld::IconView::connect_query_tooltip(rLink);
5546 m_xIconView->SetTooltipHdl(LINK(this, SalInstanceIconView, TooltipHdl));
5547 }
5548
5549 IMPL_LINK(SalInstanceIconView, DumpElemToPropertyTreeHdl, const ::IconView::json_prop_query&,
5550 rQuery, bool)
5551 {
5552 SvTreeListEntry* pEntry = std::get<1>(rQuery);
5553 return m_aGetPropertyTreeElemHdl.Call(weld::json_prop_query(
5554 std::get<0>(rQuery), SalInstanceTreeIter(pEntry), std::get<2>(rQuery)));
5555 }
5556
5557 void SalInstanceIconView::connect_get_property_tree_elem(
5558 const Link<const weld::json_prop_query&, bool>& rLink)
5559 {
5560 weld::IconView::connect_get_property_tree_elem(rLink);
5561 m_xIconView->SetDumpElemToPropertyTreeHdl(
5562 LINK(this, SalInstanceIconView, DumpElemToPropertyTreeHdl));
5563 }
5564
5565 OUString SalInstanceIconView::get_selected_id() const
5566 {
5567 assert(m_xIconView->IsUpdateMode() && "don't request selection when frozen");
5568 if (SvTreeListEntry* pEntry = m_xIconView->FirstSelected())
5569 {
5570 if (const OUString* pStr = static_cast<const OUString*>(pEntry->GetUserData()))
5571 return *pStr;
5572 }
5573 return OUString();
5574 }
5575
5576 OUString SalInstanceIconView::get_selected_text() const
5577 {
5578 assert(m_xIconView->IsUpdateMode() && "don't request selection when frozen");
5579 if (SvTreeListEntry* pEntry = m_xIconView->FirstSelected())
5580 return m_xIconView->GetEntryText(pEntry);
5581 return OUString();
5582 }
5583
5584 int SalInstanceIconView::count_selected_items() const { return m_xIconView->GetSelectionCount(); }
5585
5586 void SalInstanceIconView::select(int pos)
5587 {
5588 assert(m_xIconView->IsUpdateMode()
5589 && "don't select when frozen, select after thaw. Note selection doesn't survive a "
5590 "freeze");
5591 disable_notify_events();
5592 if (pos == -1 || (pos == 0 && n_children() == 0))
5593 m_xIconView->SelectAll(false);
5594 else
5595 {
5596 SvTreeListEntry* pEntry = m_xIconView->GetEntry(nullptr, pos);
5597 m_xIconView->Select(pEntry, true);
5598 m_xIconView->MakeVisible(pEntry);
5599 }
5600 enable_notify_events();
5601 }
5602
5603 void SalInstanceIconView::unselect(int pos)
5604 {
5605 assert(m_xIconView->IsUpdateMode()
5606 && "don't select when frozen, select after thaw. Note selection doesn't survive a "
5607 "freeze");
5608 disable_notify_events();
5609 if (pos == -1)
5610 m_xIconView->SelectAll(true);
5611 else
5612 {
5613 SvTreeListEntry* pEntry = m_xIconView->GetEntry(nullptr, pos);
5614 m_xIconView->Select(pEntry, false);
5615 }
5616 enable_notify_events();
5617 }
5618
5619 int SalInstanceIconView::n_children() const
5620 {
5621 return m_xIconView->GetModel()->GetChildList(nullptr).size();
5622 }
5623
5624 std::unique_ptr<weld::TreeIter>
5625 SalInstanceIconView::make_iterator(const weld::TreeIter* pOrig) const
5626 {
5627 return std::unique_ptr<weld::TreeIter>(
5628 new SalInstanceTreeIter(static_cast<const SalInstanceTreeIter*>(pOrig)));
5629 }
5630
5631 bool SalInstanceIconView::get_selected(weld::TreeIter* pIter) const
5632 {
5633 SvTreeListEntry* pEntry = m_xIconView->FirstSelected();
5634 auto pVclIter = static_cast<SalInstanceTreeIter*>(pIter);
5635 if (pVclIter)
5636 pVclIter->iter = pEntry;
5637 return pEntry != nullptr;
5638 }
5639
5640 bool SalInstanceIconView::get_cursor(weld::TreeIter* pIter) const
5641 {
5642 SvTreeListEntry* pEntry = m_xIconView->GetCurEntry();
5643 auto pVclIter = static_cast<SalInstanceTreeIter*>(pIter);
5644 if (pVclIter)
5645 pVclIter->iter = pEntry;
5646 return pEntry != nullptr;
5647 }
5648
5649 void SalInstanceIconView::set_cursor(const weld::TreeIter& rIter)
5650 {
5651 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
5652 disable_notify_events();
5653 m_xIconView->SetCurEntry(rVclIter.iter);
5654 enable_notify_events();
5655 }
5656
5657 bool SalInstanceIconView::get_iter_first(weld::TreeIter& rIter) const
5658 {
5659 SalInstanceTreeIter& rVclIter = static_cast<SalInstanceTreeIter&>(rIter);
5660 rVclIter.iter = m_xIconView->GetEntry(0);
5661 return rVclIter.iter != nullptr;
5662 }
5663
5664 void SalInstanceIconView::scroll_to_item(const weld::TreeIter& rIter)
5665 {
5666 assert(m_xIconView->IsUpdateMode()
5667 && "don't select when frozen, select after thaw. Note selection doesn't survive a "
5668 "freeze");
5669 disable_notify_events();
5670 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
5671 m_xIconView->MakeVisible(rVclIter.iter);
5672 enable_notify_events();
5673 }
5674
5675 void SalInstanceIconView::selected_foreach(const std::function<bool(weld::TreeIter&)>& func)
5676 {
5677 SalInstanceTreeIter aVclIter(m_xIconView->FirstSelected());
5678 while (aVclIter.iter)
5679 {
5680 if (func(aVclIter))
5681 return;
5682 aVclIter.iter = m_xIconView->NextSelected(aVclIter.iter);
5683 }
5684 }
5685
5686 OUString SalInstanceIconView::get_id(const weld::TreeIter& rIter) const
5687 {
5688 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
5689 const OUString* pStr = static_cast<const OUString*>(rVclIter.iter->GetUserData());
5690 if (pStr)
5691 return *pStr;
5692 return OUString();
5693 }
5694
5695 OUString SalInstanceIconView::get_text(const weld::TreeIter& rIter) const
5696 {
5697 const SalInstanceTreeIter& rVclIter = static_cast<const SalInstanceTreeIter&>(rIter);
5698 return SvTabListBox::GetEntryText(rVclIter.iter, 0);
5699 }
5700
5701 void SalInstanceIconView::clear()
5702 {
5703 disable_notify_events();
5704 m_xIconView->Clear();
5705 m_aUserData.clear();
5706 enable_notify_events();
5707 }
5708
5709 SalInstanceIconView::~SalInstanceIconView()
5710 {
5711 m_xIconView->SetDoubleClickHdl(Link<SvTreeListBox*, bool>());
5712 m_xIconView->SetSelectHdl(Link<SvTreeListBox*, void>());
5713 m_xIconView->SetDeselectHdl(Link<SvTreeListBox*, void>());
5714 }
5715
5716 IMPL_LINK_NOARG(SalInstanceIconView, SelectHdl, SvTreeListBox*, void)
5717 {
5718 if (notify_events_disabled())
5719 return;
5720 signal_selection_changed();
5721 }
5722
5723 IMPL_LINK_NOARG(SalInstanceIconView, DeSelectHdl, SvTreeListBox*, void)
5724 {
5725 if (notify_events_disabled())
5726 return;
5727 if (m_xIconView->GetSelectionMode() == SelectionMode::Single)
5728 return;
5729 signal_selection_changed();
5730 }
5731
5732 IMPL_LINK_NOARG(SalInstanceIconView, DoubleClickHdl, SvTreeListBox*, bool)
5733 {
5734 if (notify_events_disabled())
5735 return false;
5736 return !signal_item_activated();
5737 }
5738
5739 IMPL_LINK(SalInstanceIconView, CommandHdl, const CommandEvent&, rEvent, bool)
5740 {
5741 return m_aCommandHdl.Call(rEvent);
5742 }
5743
5744 double SalInstanceSpinButton::toField(sal_Int64 nValue) const
5745 {
5746 return static_cast<double>(nValue) / Power10(get_digits());
5747 }
5748
5749 sal_Int64 SalInstanceSpinButton::fromField(double fValue) const
5750 {
5751 auto const x = fValue * Power10(get_digits());
5752 return x == double(std::numeric_limits<sal_Int64>::max())
5753 ? std::numeric_limits<sal_Int64>::max()
5754 : sal_Int64(std::round(x));
5755 }
5756
5757 SalInstanceSpinButton::SalInstanceSpinButton(FormattedField* pButton, SalInstanceBuilder* pBuilder,
5758 bool bTakeOwnership)
5759 : SalInstanceEntry(pButton, pBuilder, bTakeOwnership)
5760 , m_xButton(pButton)
5761 , m_rFormatter(m_xButton->GetFormatter())
5762 {
5763 m_rFormatter.SetThousandsSep(false); //off by default, MetricSpinButton enables it
5764 m_xButton->SetUpHdl(LINK(this, SalInstanceSpinButton, UpDownHdl));
5765 m_xButton->SetDownHdl(LINK(this, SalInstanceSpinButton, UpDownHdl));
5766 m_xButton->SetLoseFocusHdl(LINK(this, SalInstanceSpinButton, LoseFocusHdl));
5767 m_rFormatter.SetOutputHdl(LINK(this, SalInstanceSpinButton, OutputHdl));
5768 m_rFormatter.SetInputHdl(LINK(this, SalInstanceSpinButton, InputHdl));
5769 if (Edit* pEdit = m_xButton->GetSubEdit())
5770 pEdit->SetActivateHdl(LINK(this, SalInstanceSpinButton, ActivateHdl));
5771 else
5772 m_xButton->SetActivateHdl(LINK(this, SalInstanceSpinButton, ActivateHdl));
5773 }
5774
5775 sal_Int64 SalInstanceSpinButton::get_value() const { return fromField(m_rFormatter.GetValue()); }
5776
5777 void SalInstanceSpinButton::set_value(sal_Int64 value) { m_rFormatter.SetValue(toField(value)); }
5778
5779 void SalInstanceSpinButton::set_range(sal_Int64 min, sal_Int64 max)
5780 {
5781 m_rFormatter.SetMinValue(toField(min));
5782 m_rFormatter.SetMaxValue(toField(max));
5783 }
5784
5785 void SalInstanceSpinButton::get_range(sal_Int64& min, sal_Int64& max) const
5786 {
5787 min = fromField(m_rFormatter.GetMinValue());
5788 max = fromField(m_rFormatter.GetMaxValue());
5789 }
5790
5791 void SalInstanceSpinButton::set_increments(int step, int /*page*/)
5792 {
5793 m_rFormatter.SetSpinSize(toField(step));
5794 }
5795
5796 void SalInstanceSpinButton::get_increments(int& step, int& page) const
5797 {
5798 step = fromField(m_rFormatter.GetSpinSize());
5799 page = fromField(m_rFormatter.GetSpinSize());
5800 }
5801
5802 void SalInstanceSpinButton::set_digits(unsigned int digits)
5803 {
5804 m_rFormatter.SetDecimalDigits(digits);
5805 }
5806
5807 // SpinButton may be comprised of multiple subwidgets, consider the lot as
5808 // one thing for focus
5809 bool SalInstanceSpinButton::has_focus() const { return m_xWidget->HasChildPathFocus(); }
5810
5811 //off by default for direct SpinButtons, MetricSpinButton enables it
5812 void SalInstanceSpinButton::SetUseThousandSep() { m_rFormatter.SetThousandsSep(true); }
5813
5814 unsigned int SalInstanceSpinButton::get_digits() const { return m_rFormatter.GetDecimalDigits(); }
5815
5816 SalInstanceSpinButton::~SalInstanceSpinButton()
5817 {
5818 if (Edit* pEdit = m_xButton->GetSubEdit())
5819 pEdit->SetActivateHdl(Link<Edit&, bool>());
5820 else
5821 m_xButton->SetActivateHdl(Link<Edit&, bool>());
5822 m_rFormatter.SetInputHdl(Link<sal_Int64*, TriState>());
5823 m_rFormatter.SetOutputHdl(Link<LinkParamNone*, bool>());
5824 m_xButton->SetLoseFocusHdl(Link<Control&, void>());
5825 m_xButton->SetDownHdl(Link<SpinField&, void>());
5826 m_xButton->SetUpHdl(Link<SpinField&, void>());
5827 }
5828
5829 IMPL_LINK_NOARG(SalInstanceSpinButton, ActivateHdl, Edit&, bool)
5830 {
5831 // tdf#122348 return pressed to end dialog
5832 signal_value_changed();
5833 return m_aActivateHdl.Call(*this);
5834 }
5835
5836 IMPL_LINK_NOARG(SalInstanceSpinButton, UpDownHdl, SpinField&, void) { signal_value_changed(); }
5837
5838 IMPL_LINK_NOARG(SalInstanceSpinButton, LoseFocusHdl, Control&, void) { signal_value_changed(); }
5839
5840 IMPL_LINK_NOARG(SalInstanceSpinButton, OutputHdl, LinkParamNone*, bool) { return signal_output(); }
5841
5842 IMPL_LINK(SalInstanceSpinButton, InputHdl, sal_Int64*, pResult, TriState)
5843 {
5844 int nResult;
5845 TriState eRet = signal_input(&nResult);
5846 if (eRet == TRISTATE_TRUE)
5847 *pResult = nResult;
5848 return eRet;
5849 }
5850
5851 namespace
5852 {
5853 class SalInstanceFormattedSpinButton : public SalInstanceEntry,
5854 public virtual weld::FormattedSpinButton
5855 {
5856 private:
5857 VclPtr<FormattedField> m_xButton;
5858 weld::EntryFormatter* m_pFormatter;
5859 Link<weld::Widget&, void> m_aLoseFocusHdl;
5860
5861 DECL_LINK(UpDownHdl, SpinField&, void);
5862 DECL_LINK(LoseFocusHdl, Control&, void);
5863
5864 public:
5865 SalInstanceFormattedSpinButton(FormattedField* pButton, SalInstanceBuilder* pBuilder,
5866 bool bTakeOwnership)
5867 : SalInstanceEntry(pButton, pBuilder, bTakeOwnership)
5868 , m_xButton(pButton)
5869 , m_pFormatter(nullptr)
5870 {
5871 m_xButton->SetUpHdl(LINK(this, SalInstanceFormattedSpinButton, UpDownHdl));
5872 m_xButton->SetDownHdl(LINK(this, SalInstanceFormattedSpinButton, UpDownHdl));
5873 m_xButton->SetLoseFocusHdl(LINK(this, SalInstanceFormattedSpinButton, LoseFocusHdl));
5874 }
5875
5876 virtual void set_text(const OUString& rText) override
5877 {
5878 disable_notify_events();
5879 m_xButton->SpinField::SetText(rText);
5880 enable_notify_events();
5881 }
5882
5883 virtual void connect_changed(const Link<weld::Entry&, void>& rLink) override
5884 {
5885 if (!m_pFormatter) // once a formatter is set, it takes over "changed"
5886 {
5887 SalInstanceEntry::connect_changed(rLink);
5888 return;
5889 }
5890 m_pFormatter->connect_changed(rLink);
5891 }
5892
5893 virtual void connect_focus_out(const Link<weld::Widget&, void>& rLink) override
5894 {
5895 if (!m_pFormatter) // once a formatter is set, it takes over "focus-out"
5896 {
5897 m_aLoseFocusHdl = rLink;
5898 return;
5899 }
5900 m_pFormatter->connect_focus_out(rLink);
5901 }
5902
5903 virtual void SetFormatter(weld::EntryFormatter* pFormatter) override
5904 {
5905 m_pFormatter = pFormatter;
5906 m_xButton->SetFormatter(pFormatter);
5907 }
5908
5909 virtual void sync_value_from_formatter() override
5910 {
5911 // no-op for gen
5912 }
5913
5914 virtual void sync_range_from_formatter() override
5915 {
5916 // no-op for gen
5917 }
5918
5919 virtual void sync_increments_from_formatter() override
5920 {
5921 // no-op for gen
5922 }
5923
5924 virtual Formatter& GetFormatter() override { return m_xButton->GetFormatter(); }
5925
5926 virtual ~SalInstanceFormattedSpinButton() override
5927 {
5928 m_xButton->SetLoseFocusHdl(Link<Control&, void>());
5929 m_xButton->SetDownHdl(Link<SpinField&, void>());
5930 m_xButton->SetUpHdl(Link<SpinField&, void>());
5931 }
5932 };
5933
5934 IMPL_LINK_NOARG(SalInstanceFormattedSpinButton, UpDownHdl, SpinField&, void)
5935 {
5936 signal_value_changed();
5937 }
5938
5939 IMPL_LINK_NOARG(SalInstanceFormattedSpinButton, LoseFocusHdl, Control&, void)
5940 {
5941 if (!m_pFormatter)
5942 signal_value_changed();
5943 m_aLoseFocusHdl.Call(*this);
5944 }
5945 }
5946
5947 SalInstanceLabel::SalInstanceLabel(Control* pLabel, SalInstanceBuilder* pBuilder,
5948 bool bTakeOwnership)
5949 : SalInstanceWidget(pLabel, pBuilder, bTakeOwnership)
5950 , m_xLabel(pLabel)
5951 {
5952 }
5953
5954 void SalInstanceLabel::set_label(const OUString& rText) { m_xLabel->SetText(rText); }
5955
5956 OUString SalInstanceLabel::get_label() const { return m_xLabel->GetText(); }
5957
5958 void SalInstanceLabel::set_mnemonic_widget(Widget* pTarget)
5959 {
5960 FixedText* pLabel = dynamic_cast<FixedText*>(m_xLabel.get());
5961 assert(pLabel && "can't use set_mnemonic_widget on SelectableFixedText");
5962 SalInstanceWidget* pTargetWidget = dynamic_cast<SalInstanceWidget*>(pTarget);
5963 pLabel->set_mnemonic_widget(pTargetWidget ? pTargetWidget->getWidget() : nullptr);
5964 }
5965
5966 void SalInstanceLabel::set_label_type(weld::LabelType eType)
5967 {
5968 switch (eType)
5969 {
5970 case weld::LabelType::Normal:
5971 m_xLabel->SetControlForeground();
5972 m_xLabel->SetControlBackground();
5973 break;
5974 case weld::LabelType::Warning:
5975 m_xLabel->SetControlForeground();
5976 m_xLabel->SetControlBackground(
5977 m_xLabel->GetSettings().GetStyleSettings().GetWarningColor());
5978 break;
5979 case weld::LabelType::Error:
5980 m_xLabel->SetControlForeground();
5981 m_xLabel->SetControlBackground(
5982 m_xLabel->GetSettings().GetStyleSettings().GetHighlightColor());
5983 break;
5984 case weld::LabelType::Title:
5985 m_xLabel->SetControlForeground(
5986 m_xLabel->GetSettings().GetStyleSettings().GetLightColor());
5987 m_xLabel->SetControlBackground();
5988 break;
5989 }
5990 }
5991
5992 void SalInstanceLabel::set_font_color(const Color& rColor)
5993 {
5994 if (rColor != COL_AUTO)
5995 m_xLabel->SetControlForeground(rColor);
5996 else
5997 m_xLabel->SetControlForeground();
5998 }
5999
6000 void SalInstanceLabel::set_font(const vcl::Font& rFont)
6001 {
6002 m_xLabel->SetControlFont(rFont);
6003 m_xLabel->Invalidate();
6004 }
6005
6006 std::unique_ptr<weld::Label> SalInstanceFrame::weld_label_widget() const
6007 {
6008 FixedText* pLabel = dynamic_cast<FixedText*>(m_xFrame->get_label_widget());
6009 if (!pLabel)
6010 return nullptr;
6011 return std::make_unique<SalInstanceLabel>(pLabel, m_pBuilder, false);
6012 }
6013
6014 SalInstanceTextView::SalInstanceTextView(VclMultiLineEdit* pTextView, SalInstanceBuilder* pBuilder,
6015 bool bTakeOwnership)
6016 : SalInstanceWidget(pTextView, pBuilder, bTakeOwnership)
6017 , m_xTextView(pTextView)
6018 {
6019 m_xTextView->SetModifyHdl(LINK(this, SalInstanceTextView, ChangeHdl));
6020 ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar();
6021 m_aOrigVScrollHdl = rVertScrollBar.GetScrollHdl();
6022 rVertScrollBar.SetScrollHdl(LINK(this, SalInstanceTextView, VscrollHdl));
6023 }
6024
6025 void SalInstanceTextView::set_text(const OUString& rText)
6026 {
6027 disable_notify_events();
6028 m_xTextView->SetText(rText);
6029 enable_notify_events();
6030 }
6031
6032 void SalInstanceTextView::replace_selection(const OUString& rText)
6033 {
6034 disable_notify_events();
6035 m_xTextView->ReplaceSelected(rText);
6036 enable_notify_events();
6037 }
6038
6039 OUString SalInstanceTextView::get_text() const { return m_xTextView->GetText(); }
6040
6041 bool SalInstanceTextView::get_selection_bounds(int& rStartPos, int& rEndPos)
6042 {
6043 const Selection& rSelection = m_xTextView->GetSelection();
6044 rStartPos = rSelection.Min();
6045 rEndPos = rSelection.Max();
6046 return rSelection.Len();
6047 }
6048
6049 void SalInstanceTextView::select_region(int nStartPos, int nEndPos)
6050 {
6051 disable_notify_events();
6052 tools::Long nStart = nStartPos < 0 ? SELECTION_MAX : nStartPos;
6053 tools::Long nEnd = nEndPos < 0 ? SELECTION_MAX : nEndPos;
6054 m_xTextView->SetSelection(Selection(nStart, nEnd));
6055 enable_notify_events();
6056 }
6057
6058 void SalInstanceTextView::set_editable(bool bEditable) { m_xTextView->SetReadOnly(!bEditable); }
6059 bool SalInstanceTextView::get_editable() const { return !m_xTextView->IsReadOnly(); }
6060 void SalInstanceTextView::set_max_length(int nChars) { m_xTextView->SetMaxTextLen(nChars); }
6061
6062 void SalInstanceTextView::set_monospace(bool bMonospace)
6063 {
6064 vcl::Font aOrigFont = m_xTextView->GetControlFont();
6065 vcl::Font aFont;
6066 if (bMonospace)
6067 aFont
6068 = OutputDevice::GetDefaultFont(DefaultFontType::UI_FIXED, LANGUAGE_DONTKNOW,
6069 GetDefaultFontFlags::OnlyOne, m_xTextView->GetOutDev());
6070 else
6071 aFont = Application::GetSettings().GetStyleSettings().GetFieldFont();
6072 aFont.SetFontHeight(aOrigFont.GetFontHeight());
6073 set_font(aFont);
6074 }
6075
6076 void SalInstanceTextView::set_font_color(const Color& rColor)
6077 {
6078 if (rColor != COL_AUTO)
6079 m_xTextView->SetControlForeground(rColor);
6080 else
6081 m_xTextView->SetControlForeground();
6082 }
6083
6084 void SalInstanceTextView::set_font(const vcl::Font& rFont)
6085 {
6086 m_xTextView->SetFont(rFont);
6087 m_xTextView->SetControlFont(rFont);
6088 m_xTextView->Invalidate();
6089 }
6090
6091 void SalInstanceTextView::connect_cursor_position(const Link<TextView&, void>& rLink)
6092 {
6093 assert(!m_aCursorPositionHdl.IsSet());
6094 m_xTextView->AddEventListener(LINK(this, SalInstanceTextView, CursorListener));
6095 weld::TextView::connect_cursor_position(rLink);
6096 }
6097
6098 bool SalInstanceTextView::can_move_cursor_with_up() const
6099 {
6100 bool bNoSelection = !m_xTextView->GetSelection();
6101 return !bNoSelection || m_xTextView->CanUp();
6102 }
6103
6104 bool SalInstanceTextView::can_move_cursor_with_down() const
6105 {
6106 bool bNoSelection = !m_xTextView->GetSelection();
6107 return !bNoSelection || m_xTextView->CanDown();
6108 }
6109
6110 void SalInstanceTextView::cut_clipboard() { m_xTextView->Cut(); }
6111
6112 void SalInstanceTextView::copy_clipboard() { m_xTextView->Copy(); }
6113
6114 void SalInstanceTextView::paste_clipboard() { m_xTextView->Paste(); }
6115
6116 void SalInstanceTextView::set_alignment(TxtAlign eXAlign)
6117 {
6118 ::set_alignment(*m_xTextView, eXAlign);
6119 }
6120
6121 int SalInstanceTextView::vadjustment_get_value() const
6122 {
6123 ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar();
6124 return rVertScrollBar.GetThumbPos();
6125 }
6126
6127 void SalInstanceTextView::vadjustment_set_value(int value)
6128 {
6129 ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar();
6130 rVertScrollBar.SetThumbPos(value);
6131 m_aOrigVScrollHdl.Call(&rVertScrollBar);
6132 }
6133
6134 int SalInstanceTextView::vadjustment_get_upper() const
6135 {
6136 ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar();
6137 return rVertScrollBar.GetRangeMax();
6138 }
6139
6140 int SalInstanceTextView::vadjustment_get_lower() const
6141 {
6142 ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar();
6143 return rVertScrollBar.GetRangeMin();
6144 }
6145
6146 int SalInstanceTextView::vadjustment_get_page_size() const
6147 {
6148 ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar();
6149 return rVertScrollBar.GetVisibleSize();
6150 }
6151
6152 bool SalInstanceTextView::has_focus() const { return m_xTextView->HasChildPathFocus(); }
6153
6154 SalInstanceTextView::~SalInstanceTextView()
6155 {
6156 if (!m_xTextView->isDisposed())
6157 {
6158 if (m_aCursorPositionHdl.IsSet())
6159 m_xTextView->RemoveEventListener(LINK(this, SalInstanceTextView, CursorListener));
6160 m_xTextView->SetModifyHdl(Link<Edit&, void>());
6161 ScrollBar& rVertScrollBar = m_xTextView->GetVScrollBar();
6162 rVertScrollBar.SetScrollHdl(m_aOrigVScrollHdl);
6163 }
6164 }
6165
6166 IMPL_LINK(SalInstanceTextView, VscrollHdl, ScrollBar*, pScrollBar, void)
6167 {
6168 signal_vadjustment_changed();
6169 m_aOrigVScrollHdl.Call(pScrollBar);
6170 }
6171
6172 IMPL_LINK_NOARG(SalInstanceTextView, ChangeHdl, Edit&, void) { signal_changed(); }
6173
6174 IMPL_LINK(SalInstanceTextView, CursorListener, VclWindowEvent&, rEvent, void)
6175 {
6176 if (notify_events_disabled())
6177 return;
6178 if (rEvent.GetId() == VclEventId::EditSelectionChanged
6179 || rEvent.GetId() == VclEventId::EditCaretChanged)
6180 signal_cursor_position();
6181 }
6182
6183 SalInstanceExpander::SalInstanceExpander(VclExpander* pExpander, SalInstanceBuilder* pBuilder,
6184 bool bTakeOwnership)
6185 : SalInstanceWidget(pExpander, pBuilder, bTakeOwnership)
6186 , m_xExpander(pExpander)
6187 {
6188 m_xExpander->SetExpandedHdl(LINK(this, SalInstanceExpander, ExpandedHdl));
6189 }
6190
6191 void SalInstanceExpander::set_label(const OUString& rText) { m_xExpander->set_label(rText); }
6192
6193 OUString SalInstanceExpander::get_label() const { return m_xExpander->get_label(); }
6194
6195 bool SalInstanceExpander::get_expanded() const { return m_xExpander->get_expanded(); }
6196
6197 void SalInstanceExpander::set_expanded(bool bExpand) { m_xExpander->set_expanded(bExpand); }
6198
6199 bool SalInstanceExpander::has_focus() const
6200 {
6201 return m_xExpander->get_label_widget()->HasFocus() || SalInstanceWidget::has_focus();
6202 }
6203
6204 void SalInstanceExpander::grab_focus() { return m_xExpander->get_label_widget()->GrabFocus(); }
6205
6206 SalInstanceExpander::~SalInstanceExpander()
6207 {
6208 m_xExpander->SetExpandedHdl(Link<VclExpander&, void>());
6209 }
6210
6211 IMPL_LINK_NOARG(SalInstanceExpander, ExpandedHdl, VclExpander&, void) { signal_expanded(); }
6212
6213 // SalInstanceWidget has a generic listener for all these
6214 // events, ignore the ones we have specializations for
6215 // in VclDrawingArea
6216 void SalInstanceDrawingArea::HandleEventListener(VclWindowEvent& rEvent)
6217 {
6218 if (rEvent.GetId() == VclEventId::WindowResize)
6219 return;
6220 SalInstanceWidget::HandleEventListener(rEvent);
6221 }
6222
6223 void SalInstanceDrawingArea::HandleMouseEventListener(VclWindowEvent& rEvent)
6224 {
6225 if (rEvent.GetId() == VclEventId::WindowMouseButtonDown
6226 || rEvent.GetId() == VclEventId::WindowMouseButtonUp
6227 || rEvent.GetId() == VclEventId::WindowMouseMove)
6228 {
6229 return;
6230 }
6231 SalInstanceWidget::HandleMouseEventListener(rEvent);
6232 }
6233
6234 bool SalInstanceDrawingArea::HandleKeyEventListener(VclWindowEvent& /*rEvent*/) { return false; }
6235
6236 SalInstanceDrawingArea::SalInstanceDrawingArea(VclDrawingArea* pDrawingArea,
6237 SalInstanceBuilder* pBuilder, const a11yref& rAlly,
6238 FactoryFunction pUITestFactoryFunction,
6239 void* pUserData, bool bTakeOwnership)
6240 : SalInstanceWidget(pDrawingArea, pBuilder, bTakeOwnership)
6241 , m_xDrawingArea(pDrawingArea)
6242 {
6243 m_xDrawingArea->SetAccessible(rAlly);
6244 m_xDrawingArea->SetUITestFactory(std::move(pUITestFactoryFunction), pUserData);
6245 m_xDrawingArea->SetPaintHdl(LINK(this, SalInstanceDrawingArea, PaintHdl));
6246 m_xDrawingArea->SetResizeHdl(LINK(this, SalInstanceDrawingArea, ResizeHdl));
6247 m_xDrawingArea->SetMousePressHdl(LINK(this, SalInstanceDrawingArea, MousePressHdl));
6248 m_xDrawingArea->SetMouseMoveHdl(LINK(this, SalInstanceDrawingArea, MouseMoveHdl));
6249 m_xDrawingArea->SetMouseReleaseHdl(LINK(this, SalInstanceDrawingArea, MouseReleaseHdl));
6250 m_xDrawingArea->SetKeyPressHdl(LINK(this, SalInstanceDrawingArea, KeyPressHdl));
6251 m_xDrawingArea->SetKeyReleaseHdl(LINK(this, SalInstanceDrawingArea, KeyReleaseHdl));
6252 m_xDrawingArea->SetStyleUpdatedHdl(LINK(this, SalInstanceDrawingArea, StyleUpdatedHdl));
6253 m_xDrawingArea->SetCommandHdl(LINK(this, SalInstanceDrawingArea, CommandHdl));
6254 m_xDrawingArea->SetQueryTooltipHdl(LINK(this, SalInstanceDrawingArea, QueryTooltipHdl));
6255 m_xDrawingArea->SetGetSurroundingHdl(LINK(this, SalInstanceDrawingArea, GetSurroundingHdl));
6256 m_xDrawingArea->SetDeleteSurroundingHdl(
6257 LINK(this, SalInstanceDrawingArea, DeleteSurroundingHdl));
6258 m_xDrawingArea->SetStartDragHdl(LINK(this, SalInstanceDrawingArea, StartDragHdl));
6259 }
6260
6261 void SalInstanceDrawingArea::queue_draw() { m_xDrawingArea->Invalidate(); }
6262
6263 void SalInstanceDrawingArea::queue_draw_area(int x, int y, int width, int height)
6264 {
6265 m_xDrawingArea->Invalidate(tools::Rectangle(Point(x, y), Size(width, height)));
6266 }
6267
6268 void SalInstanceDrawingArea::connect_size_allocate(const Link<const Size&, void>& rLink)
6269 {
6270 weld::Widget::connect_size_allocate(rLink);
6271 }
6272
6273 void SalInstanceDrawingArea::connect_key_press(const Link<const KeyEvent&, bool>& rLink)
6274 {
6275 weld::Widget::connect_key_press(rLink);
6276 }
6277
6278 void SalInstanceDrawingArea::connect_key_release(const Link<const KeyEvent&, bool>& rLink)
6279 {
6280 weld::Widget::connect_key_release(rLink);
6281 }
6282
6283 void SalInstanceDrawingArea::connect_style_updated(const Link<Widget&, void>& rLink)
6284 {
6285 weld::Widget::connect_style_updated(rLink);
6286 }
6287
6288 void SalInstanceDrawingArea::set_cursor(PointerStyle ePointerStyle)
6289 {
6290 m_xDrawingArea->SetPointer(ePointerStyle);
6291 }
6292
6293 void SalInstanceDrawingArea::set_input_context(const InputContext& rInputContext)
6294 {
6295 m_xDrawingArea->SetInputContext(rInputContext);
6296 }
6297
6298 void SalInstanceDrawingArea::im_context_set_cursor_location(const tools::Rectangle& rCursorRect,
6299 int nExtTextInputWidth)
6300 {
6301 tools::Rectangle aCursorRect = m_xDrawingArea->PixelToLogic(rCursorRect);
6302 m_xDrawingArea->SetCursorRect(
6303 &aCursorRect, m_xDrawingArea->PixelToLogic(Size(nExtTextInputWidth, 0)).Width());
6304 }
6305
6306 a11yref SalInstanceDrawingArea::get_accessible_parent()
6307 {
6308 vcl::Window* pParent = m_xDrawingArea->GetParent();
6309 if (pParent)
6310 return pParent->GetAccessible();
6311 return css::uno::Reference<css::accessibility::XAccessible>();
6312 }
6313
6314 a11yrelationset SalInstanceDrawingArea::get_accessible_relation_set()
6315 {
6316 rtl::Reference<utl::AccessibleRelationSetHelper> pRelationSetHelper
6317 = new utl::AccessibleRelationSetHelper;
6318 vcl::Window* pWindow = m_xDrawingArea.get();
6319 if (pWindow)
6320 {
6321 vcl::Window* pLabeledBy = pWindow->GetAccessibleRelationLabeledBy();
6322 if (pLabeledBy && pLabeledBy != pWindow)
6323 {
6324 css::uno::Sequence<css::uno::Reference<css::uno::XInterface>> aSequence{
6325 pLabeledBy->GetAccessible()
6326 };
6327 pRelationSetHelper->AddRelation(css::accessibility::AccessibleRelation(
6328 css::accessibility::AccessibleRelationType::LABELED_BY, aSequence));
6329 }
6330 vcl::Window* pMemberOf = pWindow->GetAccessibleRelationMemberOf();
6331 if (pMemberOf && pMemberOf != pWindow)
6332 {
6333 css::uno::Sequence<css::uno::Reference<css::uno::XInterface>> aSequence{
6334 pMemberOf->GetAccessible()
6335 };
6336 pRelationSetHelper->AddRelation(css::accessibility::AccessibleRelation(
6337 css::accessibility::AccessibleRelationType::MEMBER_OF, aSequence));
6338 }
6339 }
6340 return pRelationSetHelper;
6341 }
6342
6343 Point SalInstanceDrawingArea::get_accessible_location_on_screen()
6344 {
6345 return m_xDrawingArea->OutputToAbsoluteScreenPixel(Point());
6346 }
6347
6348 Point SalInstanceDrawingArea::get_pointer_position() const
6349 {
6350 return m_xDrawingArea->GetPointerPosPixel();
6351 }
6352
6353 void SalInstanceDrawingArea::enable_drag_source(rtl::Reference<TransferDataContainer>& rHelper,
6354 sal_uInt8 eDNDConstants)
6355 {
6356 m_xDrawingArea->SetDragHelper(rHelper, eDNDConstants);
6357 }
6358
6359 SalInstanceDrawingArea::~SalInstanceDrawingArea()
6360 {
6361 m_xDrawingArea->SetDeleteSurroundingHdl(Link<const Selection&, bool>());
6362 m_xDrawingArea->SetGetSurroundingHdl(Link<OUString&, int>());
6363 m_xDrawingArea->SetQueryTooltipHdl(Link<tools::Rectangle&, OUString>());
6364 m_xDrawingArea->SetCommandHdl(Link<const CommandEvent&, bool>());
6365 m_xDrawingArea->SetStyleUpdatedHdl(Link<VclDrawingArea&, void>());
6366 m_xDrawingArea->SetMousePressHdl(Link<const MouseEvent&, bool>());
6367 m_xDrawingArea->SetMouseMoveHdl(Link<const MouseEvent&, bool>());
6368 m_xDrawingArea->SetMouseReleaseHdl(Link<const MouseEvent&, bool>());
6369 m_xDrawingArea->SetKeyPressHdl(Link<const KeyEvent&, bool>());
6370 m_xDrawingArea->SetKeyReleaseHdl(Link<const KeyEvent&, bool>());
6371 m_xDrawingArea->SetResizeHdl(Link<const Size&, void>());
6372 m_xDrawingArea->SetPaintHdl(
6373 Link<std::pair<vcl::RenderContext&, const tools::Rectangle&>, void>());
6374 }
6375
6376 OutputDevice& SalInstanceDrawingArea::get_ref_device() { return *m_xDrawingArea->GetOutDev(); }
6377
6378 void SalInstanceDrawingArea::click(const Point& rPos)
6379 {
6380 MouseEvent aEvent(rPos, 1, MouseEventModifiers::NONE, MOUSE_LEFT, 0);
6381 VclPtr<VclDrawingArea> xDrawingArea(m_xDrawingArea);
6382 xDrawingArea->MouseButtonDown(aEvent);
6383 xDrawingArea->MouseButtonUp(aEvent);
6384 }
6385
6386 void SalInstanceDrawingArea::dblclick(const Point& rPos)
6387 {
6388 MouseEvent aEvent(rPos, 2, MouseEventModifiers::NONE, MOUSE_LEFT, 0);
6389 VclPtr<VclDrawingArea> xDrawingArea(m_xDrawingArea);
6390 xDrawingArea->MouseButtonDown(aEvent);
6391 xDrawingArea->MouseButtonUp(aEvent);
6392 }
6393
6394 void SalInstanceDrawingArea::mouse_up(const Point& rPos)
6395 {
6396 MouseEvent aEvent(rPos, 0, MouseEventModifiers::NONE, MOUSE_LEFT, 0);
6397 m_xDrawingArea->MouseButtonUp(aEvent);
6398 }
6399
6400 void SalInstanceDrawingArea::mouse_down(const Point& rPos)
6401 {
6402 MouseEvent aEvent(rPos, 0, MouseEventModifiers::NONE, MOUSE_LEFT, 0);
6403 m_xDrawingArea->MouseButtonDown(aEvent);
6404 }
6405
6406 void SalInstanceDrawingArea::mouse_move(const Point& rPos)
6407 {
6408 MouseEvent aEvent(rPos, 0, MouseEventModifiers::NONE, MOUSE_LEFT, 0);
6409 m_xDrawingArea->MouseMove(aEvent);
6410 }
6411
6412 IMPL_LINK(SalInstanceDrawingArea, PaintHdl, target_and_area, aPayload, void)
6413 {
6414 m_aDrawHdl.Call(aPayload);
6415 tools::Rectangle aFocusRect(m_aGetFocusRectHdl.Call(*this));
6416 if (!aFocusRect.IsEmpty())
6417 InvertFocusRect(aPayload.first, aFocusRect);
6418 }
6419
6420 IMPL_LINK(SalInstanceDrawingArea, ResizeHdl, const Size&, rSize, void)
6421 {
6422 m_aSizeAllocateHdl.Call(rSize);
6423 }
6424
6425 IMPL_LINK(SalInstanceDrawingArea, MousePressHdl, const MouseEvent&, rEvent, bool)
6426 {
6427 return m_aMousePressHdl.Call(rEvent);
6428 }
6429
6430 IMPL_LINK(SalInstanceDrawingArea, MouseMoveHdl, const MouseEvent&, rEvent, bool)
6431 {
6432 return m_aMouseMotionHdl.Call(rEvent);
6433 }
6434
6435 IMPL_LINK(SalInstanceDrawingArea, MouseReleaseHdl, const MouseEvent&, rEvent, bool)
6436 {
6437 return m_aMouseReleaseHdl.Call(rEvent);
6438 }
6439
6440 IMPL_LINK(SalInstanceDrawingArea, KeyPressHdl, const KeyEvent&, rEvent, bool)
6441 {
6442 return m_aKeyPressHdl.Call(rEvent);
6443 }
6444
6445 IMPL_LINK(SalInstanceDrawingArea, KeyReleaseHdl, const KeyEvent&, rEvent, bool)
6446 {
6447 return m_aKeyReleaseHdl.Call(rEvent);
6448 }
6449
6450 IMPL_LINK_NOARG(SalInstanceDrawingArea, StyleUpdatedHdl, VclDrawingArea&, void)
6451 {
6452 m_aStyleUpdatedHdl.Call(*this);
6453 }
6454
6455 IMPL_LINK(SalInstanceDrawingArea, CommandHdl, const CommandEvent&, rEvent, bool)
6456 {
6457 return m_aCommandHdl.Call(rEvent);
6458 }
6459
6460 IMPL_LINK(SalInstanceDrawingArea, GetSurroundingHdl, OUString&, rSurrounding, int)
6461 {
6462 return m_aGetSurroundingHdl.Call(rSurrounding);
6463 }
6464
6465 IMPL_LINK(SalInstanceDrawingArea, DeleteSurroundingHdl, const Selection&, rSelection, bool)
6466 {
6467 return m_aDeleteSurroundingHdl.Call(rSelection);
6468 }
6469
6470 IMPL_LINK(SalInstanceDrawingArea, QueryTooltipHdl, tools::Rectangle&, rHelpArea, OUString)
6471 {
6472 return m_aQueryTooltipHdl.Call(rHelpArea);
6473 }
6474
6475 IMPL_LINK_NOARG(SalInstanceDrawingArea, StartDragHdl, VclDrawingArea*, bool)
6476 {
6477 if (m_aDragBeginHdl.Call(*this))
6478 return true;
6479 return false;
6480 }
6481
6482 SalInstanceComboBoxWithoutEdit::SalInstanceComboBoxWithoutEdit(ListBox* pListBox,
6483 SalInstanceBuilder* pBuilder,
6484 bool bTakeOwnership)
6485 : SalInstanceComboBox<ListBox>(pListBox, pBuilder, bTakeOwnership)
6486 {
6487 m_xComboBox->SetSelectHdl(LINK(this, SalInstanceComboBoxWithoutEdit, SelectHdl));
6488 }
6489
6490 OUString SalInstanceComboBoxWithoutEdit::get_active_text() const
6491 {
6492 return m_xComboBox->GetSelectedEntry();
6493 }
6494
6495 void SalInstanceComboBoxWithoutEdit::remove(int pos) { m_xComboBox->RemoveEntry(pos); }
6496
6497 void SalInstanceComboBoxWithoutEdit::insert(int pos, const OUString& rStr, const OUString* pId,
6498 const OUString* pIconName, VirtualDevice* pImageSurface)
6499 {
6500 auto nInsertPos = pos == -1 ? COMBOBOX_APPEND : pos;
6501 sal_Int32 nInsertedAt;
6502 if (!pIconName && !pImageSurface)
6503 nInsertedAt = m_xComboBox->InsertEntry(rStr, nInsertPos);
6504 else if (pIconName)
6505 nInsertedAt = m_xComboBox->InsertEntry(rStr, createImage(*pIconName), nInsertPos);
6506 else
6507 nInsertedAt = m_xComboBox->InsertEntry(rStr, createImage(*pImageSurface), nInsertPos);
6508 if (pId)
6509 {
6510 m_aUserData.emplace_back(std::make_unique<OUString>(*pId));
6511 m_xComboBox->SetEntryData(nInsertedAt, m_aUserData.back().get());
6512 }
6513 }
6514
6515 void SalInstanceComboBoxWithoutEdit::insert_separator(int pos, const OUString& /*rId*/)
6516 {
6517 auto nInsertPos = pos == -1 ? m_xComboBox->GetEntryCount() : pos;
6518 m_xComboBox->AddSeparator(nInsertPos - 1);
6519 }
6520
6521 bool SalInstanceComboBoxWithoutEdit::has_entry() const { return false; }
6522
6523 bool SalInstanceComboBoxWithoutEdit::changed_by_direct_pick() const { return true; }
6524
6525 void SalInstanceComboBoxWithoutEdit::set_entry_message_type(weld::EntryMessageType /*eType*/)
6526 {
6527 assert(false);
6528 }
6529
6530 void SalInstanceComboBoxWithoutEdit::set_entry_text(const OUString& /*rText*/) { assert(false); }
6531
6532 void SalInstanceComboBoxWithoutEdit::select_entry_region(int /*nStartPos*/, int /*nEndPos*/)
6533 {
6534 assert(false);
6535 }
6536
6537 bool SalInstanceComboBoxWithoutEdit::get_entry_selection_bounds(int& /*rStartPos*/,
6538 int& /*rEndPos*/)
6539 {
6540 assert(false);
6541 return false;
6542 }
6543
6544 void SalInstanceComboBoxWithoutEdit::set_entry_width_chars(int /*nChars*/) { assert(false); }
6545
6546 void SalInstanceComboBoxWithoutEdit::set_entry_max_length(int /*nChars*/) { assert(false); }
6547
6548 void SalInstanceComboBoxWithoutEdit::set_entry_completion(bool, bool) { assert(false); }
6549
6550 void SalInstanceComboBoxWithoutEdit::set_entry_placeholder_text(const OUString&) { assert(false); }
6551
6552 void SalInstanceComboBoxWithoutEdit::set_entry_editable(bool /*bEditable*/) { assert(false); }
6553
6554 void SalInstanceComboBoxWithoutEdit::cut_entry_clipboard() { assert(false); }
6555
6556 void SalInstanceComboBoxWithoutEdit::copy_entry_clipboard() { assert(false); }
6557
6558 void SalInstanceComboBoxWithoutEdit::paste_entry_clipboard() { assert(false); }
6559
6560 void SalInstanceComboBoxWithoutEdit::set_font(const vcl::Font& rFont)
6561 {
6562 m_xComboBox->SetControlFont(rFont);
6563 m_xComboBox->Invalidate();
6564 }
6565
6566 void SalInstanceComboBoxWithoutEdit::set_entry_font(const vcl::Font&) { assert(false); }
6567
6568 vcl::Font SalInstanceComboBoxWithoutEdit::get_entry_font()
6569 {
6570 assert(false);
6571 return vcl::Font();
6572 }
6573
6574 void SalInstanceComboBoxWithoutEdit::set_custom_renderer(bool /*bOn*/)
6575 {
6576 assert(false && "not implemented");
6577 }
6578
6579 int SalInstanceComboBoxWithoutEdit::get_max_mru_count() const
6580 {
6581 assert(false && "not implemented");
6582 return 0;
6583 }
6584
6585 void SalInstanceComboBoxWithoutEdit::set_max_mru_count(int) { assert(false && "not implemented"); }
6586
6587 OUString SalInstanceComboBoxWithoutEdit::get_mru_entries() const
6588 {
6589 assert(false && "not implemented");
6590 return OUString();
6591 }
6592
6593 void SalInstanceComboBoxWithoutEdit::set_mru_entries(const OUString&)
6594 {
6595 assert(false && "not implemented");
6596 }
6597
6598 void SalInstanceComboBoxWithoutEdit::HandleEventListener(VclWindowEvent& rEvent)
6599 {
6600 CallHandleEventListener(rEvent);
6601 }
6602
6603 SalInstanceComboBoxWithoutEdit::~SalInstanceComboBoxWithoutEdit()
6604 {
6605 m_xComboBox->SetSelectHdl(Link<ListBox&, void>());
6606 }
6607
6608 IMPL_LINK_NOARG(SalInstanceComboBoxWithoutEdit, SelectHdl, ListBox&, void)
6609 {
6610 return signal_changed();
6611 }
6612
6613 SalInstanceComboBoxWithEdit::SalInstanceComboBoxWithEdit(::ComboBox* pComboBox,
6614 SalInstanceBuilder* pBuilder,
6615 bool bTakeOwnership)
6616 : SalInstanceComboBox<::ComboBox>(pComboBox, pBuilder, bTakeOwnership)
6617 , m_aTextFilter(m_aEntryInsertTextHdl)
6618 , m_bInSelect(false)
6619 {
6620 m_xComboBox->SetModifyHdl(LINK(this, SalInstanceComboBoxWithEdit, ChangeHdl));
6621 m_xComboBox->SetSelectHdl(LINK(this, SalInstanceComboBoxWithEdit, SelectHdl));
6622 m_xComboBox->SetEntryActivateHdl(LINK(this, SalInstanceComboBoxWithEdit, EntryActivateHdl));
6623 m_xComboBox->SetTextFilter(&m_aTextFilter);
6624 }
6625
6626 bool SalInstanceComboBoxWithEdit::has_entry() const { return true; }
6627
6628 void SalInstanceComboBoxWithEdit::call_attention_to()
6629 {
6630 Edit* pEdit = m_xComboBox->GetSubEdit();
6631 assert(pEdit);
6632 m_xFlashAttention.reset(new SalFlashAttention(pEdit));
6633 m_xFlashAttention->Start();
6634 }
6635
6636 bool SalInstanceComboBoxWithEdit::changed_by_direct_pick() const
6637 {
6638 return m_bInSelect && !m_xComboBox->IsModifyByKeyboard() && !m_xComboBox->IsTravelSelect();
6639 }
6640
6641 void SalInstanceComboBoxWithEdit::set_entry_message_type(weld::EntryMessageType eType)
6642 {
6643 Edit* pEdit = m_xComboBox->GetSubEdit();
6644 assert(pEdit);
6645 ::set_message_type(pEdit, eType);
6646 }
6647
6648 OUString SalInstanceComboBoxWithEdit::get_active_text() const { return m_xComboBox->GetText(); }
6649
6650 void SalInstanceComboBoxWithEdit::remove(int pos) { m_xComboBox->RemoveEntryAt(pos); }
6651
6652 void SalInstanceComboBoxWithEdit::insert(int pos, const OUString& rStr, const OUString* pId,
6653 const OUString* pIconName, VirtualDevice* pImageSurface)
6654 {
6655 auto nInsertPos = pos == -1 ? COMBOBOX_APPEND : pos;
6656 sal_Int32 nInsertedAt;
6657 if (!pIconName && !pImageSurface)
6658 nInsertedAt = m_xComboBox->InsertEntry(rStr, nInsertPos);
6659 else if (pIconName)
6660 nInsertedAt = m_xComboBox->InsertEntryWithImage(rStr, createImage(*pIconName), nInsertPos);
6661 else
6662 nInsertedAt
6663 = m_xComboBox->InsertEntryWithImage(rStr, createImage(*pImageSurface), nInsertPos);
6664 if (pId)
6665 {
6666 m_aUserData.emplace_back(std::make_unique<OUString>(*pId));
6667 m_xComboBox->SetEntryData(nInsertedAt, m_aUserData.back().get());
6668 }
6669 }
6670
6671 void SalInstanceComboBoxWithEdit::insert_separator(int pos, const OUString& /*rId*/)
6672 {
6673 auto nInsertPos = pos == -1 ? m_xComboBox->GetEntryCount() : pos;
6674 m_xComboBox->AddSeparator(nInsertPos - 1);
6675 }
6676
6677 void SalInstanceComboBoxWithEdit::set_entry_text(const OUString& rText)
6678 {
6679 m_xComboBox->SetText(rText);
6680 }
6681
6682 void SalInstanceComboBoxWithEdit::set_entry_width_chars(int nChars)
6683 {
6684 m_xComboBox->SetWidthInChars(nChars);
6685 }
6686
6687 void SalInstanceComboBoxWithEdit::set_entry_max_length(int nChars)
6688 {
6689 m_xComboBox->SetMaxTextLen(nChars);
6690 }
6691
6692 void SalInstanceComboBoxWithEdit::set_entry_completion(bool bEnable, bool bCaseSensitive)
6693 {
6694 m_xComboBox->EnableAutocomplete(bEnable, bCaseSensitive);
6695 }
6696
6697 void SalInstanceComboBoxWithEdit::set_entry_placeholder_text(const OUString& rText)
6698 {
6699 m_xComboBox->SetPlaceholderText(rText);
6700 }
6701
6702 void SalInstanceComboBoxWithEdit::set_entry_editable(bool bEditable)
6703 {
6704 m_xComboBox->SetReadOnly(!bEditable);
6705 }
6706
6707 void SalInstanceComboBoxWithEdit::cut_entry_clipboard() { m_xComboBox->Cut(); }
6708
6709 void SalInstanceComboBoxWithEdit::copy_entry_clipboard() { m_xComboBox->Copy(); }
6710
6711 void SalInstanceComboBoxWithEdit::paste_entry_clipboard() { m_xComboBox->Paste(); }
6712
6713 void SalInstanceComboBoxWithEdit::select_entry_region(int nStartPos, int nEndPos)
6714 {
6715 m_xComboBox->SetSelection(Selection(nStartPos, nEndPos < 0 ? SELECTION_MAX : nEndPos));
6716 }
6717
6718 bool SalInstanceComboBoxWithEdit::get_entry_selection_bounds(int& rStartPos, int& rEndPos)
6719 {
6720 const Selection& rSelection = m_xComboBox->GetSelection();
6721 rStartPos = rSelection.Min();
6722 rEndPos = rSelection.Max();
6723 return rSelection.Len();
6724 }
6725
6726 void SalInstanceComboBoxWithEdit::set_font(const vcl::Font& rFont)
6727 {
6728 m_xComboBox->SetControlFont(rFont);
6729 m_xComboBox->Invalidate();
6730 }
6731
6732 void SalInstanceComboBoxWithEdit::set_entry_font(const vcl::Font& rFont)
6733 {
6734 Edit* pEdit = m_xComboBox->GetSubEdit();
6735 assert(pEdit);
6736 pEdit->SetControlFont(rFont); // tdf#134601 set it as control font to take effect properly
6737 pEdit->Invalidate();
6738 }
6739
6740 vcl::Font SalInstanceComboBoxWithEdit::get_entry_font()
6741 {
6742 Edit* pEdit = m_xComboBox->GetSubEdit();
6743 assert(pEdit);
6744 return pEdit->GetPointFont(*pEdit->GetOutDev());
6745 }
6746
6747 void SalInstanceComboBoxWithEdit::set_custom_renderer(bool bOn)
6748 {
6749 if (m_xComboBox->IsUserDrawEnabled() == bOn)
6750 return;
6751
6752 auto nOldEntryHeight = m_xComboBox->GetDropDownEntryHeight();
6753 auto nDropDownLineCount = m_xComboBox->GetDropDownLineCount();
6754
6755 m_xComboBox->EnableUserDraw(bOn);
6756 if (bOn)
6757 m_xComboBox->SetUserDrawHdl(LINK(this, SalInstanceComboBoxWithEdit, UserDrawHdl));
6758 else
6759 m_xComboBox->SetUserDrawHdl(Link<UserDrawEvent*, void>());
6760
6761 // adjust the line count to fit approx the height it would have been before
6762 // changing the renderer
6763 auto nNewEntryHeight = m_xComboBox->GetDropDownEntryHeight();
6764 double fRatio = nOldEntryHeight / static_cast<double>(nNewEntryHeight);
6765 m_xComboBox->SetDropDownLineCount(nDropDownLineCount * fRatio);
6766 }
6767
6768 int SalInstanceComboBoxWithEdit::get_max_mru_count() const { return m_xComboBox->GetMaxMRUCount(); }
6769
6770 void SalInstanceComboBoxWithEdit::set_max_mru_count(int nCount)
6771 {
6772 return m_xComboBox->SetMaxMRUCount(nCount);
6773 }
6774
6775 OUString SalInstanceComboBoxWithEdit::get_mru_entries() const
6776 {
6777 return m_xComboBox->GetMRUEntries();
6778 }
6779
6780 void SalInstanceComboBoxWithEdit::set_mru_entries(const OUString& rEntries)
6781 {
6782 m_xComboBox->SetMRUEntries(rEntries);
6783 }
6784
6785 void SalInstanceComboBoxWithEdit::HandleEventListener(VclWindowEvent& rEvent)
6786 {
6787 if (rEvent.GetId() == VclEventId::DropdownPreOpen)
6788 {
6789 Size aRowSize(signal_custom_get_size(*m_xComboBox->GetOutDev()));
6790 m_xComboBox->SetUserItemSize(aRowSize);
6791 }
6792 CallHandleEventListener(rEvent);
6793 }
6794
6795 SalInstanceComboBoxWithEdit::~SalInstanceComboBoxWithEdit()
6796 {
6797 m_xComboBox->SetTextFilter(nullptr);
6798 m_xComboBox->SetEntryActivateHdl(Link<Edit&, bool>());
6799 m_xComboBox->SetModifyHdl(Link<Edit&, void>());
6800 m_xComboBox->SetSelectHdl(Link<::ComboBox&, void>());
6801 }
6802
6803 IMPL_LINK_NOARG(SalInstanceComboBoxWithEdit, ChangeHdl, Edit&, void)
6804 {
6805 if (!m_xComboBox->IsSyntheticModify()) // SelectHdl will be called
6806 signal_changed();
6807 }
6808
6809 IMPL_LINK_NOARG(SalInstanceComboBoxWithEdit, SelectHdl, ::ComboBox&, void)
6810 {
6811 m_bInSelect = true;
6812 signal_changed();
6813 m_bInSelect = false;
6814 }
6815
6816 IMPL_LINK_NOARG(SalInstanceComboBoxWithEdit, EntryActivateHdl, Edit&, bool)
6817 {
6818 return m_aEntryActivateHdl.Call(*this);
6819 }
6820
6821 IMPL_LINK(SalInstanceComboBoxWithEdit, UserDrawHdl, UserDrawEvent*, pEvent, void)
6822 {
6823 call_signal_custom_render(pEvent);
6824 }
6825
6826 class SalInstanceEntryTreeView : public SalInstanceContainer, public virtual weld::EntryTreeView
6827 {
6828 private:
6829 DECL_LINK(AutocompleteHdl, Edit&, void);
6830 DECL_LINK(KeyPressListener, VclWindowEvent&, void);
6831 SalInstanceEntry* m_pEntry;
6832 SalInstanceTreeView* m_pTreeView;
6833 bool m_bTreeChange;
6834
6835 public:
6836 SalInstanceEntryTreeView(vcl::Window* pContainer, SalInstanceBuilder* pBuilder,
6837 bool bTakeOwnership, std::unique_ptr<weld::Entry> xEntry,
6838 std::unique_ptr<weld::TreeView> xTreeView)
6839 : EntryTreeView(std::move(xEntry), std::move(xTreeView))
6840 , SalInstanceContainer(pContainer, pBuilder, bTakeOwnership)
6841 , m_pEntry(dynamic_cast<SalInstanceEntry*>(m_xEntry.get()))
6842 , m_pTreeView(dynamic_cast<SalInstanceTreeView*>(m_xTreeView.get()))
6843 , m_bTreeChange(false)
6844 {
6845 assert(m_pEntry && m_pTreeView);
6846
6847 Edit& rEntry = m_pEntry->getEntry();
6848 rEntry.SetAutocompleteHdl(LINK(this, SalInstanceEntryTreeView, AutocompleteHdl));
6849 rEntry.AddEventListener(LINK(this, SalInstanceEntryTreeView, KeyPressListener));
6850 }
6851
6852 virtual void insert_separator(int /*pos*/, const OUString& /*rId*/) override { assert(false); }
6853
6854 virtual void make_sorted() override
6855 {
6856 vcl::Window* pTreeView = m_pTreeView->getWidget();
6857 pTreeView->SetStyle(pTreeView->GetStyle() | WB_SORT);
6858 }
6859
6860 virtual void set_entry_completion(bool bEnable, bool /*bCaseSensitive*/) override
6861 {
6862 assert(!bEnable && "not implemented yet");
6863 (void)bEnable;
6864 Edit& rEntry = m_pEntry->getEntry();
6865 rEntry.SetAutocompleteHdl(Link<Edit&, void>());
6866 }
6867
6868 virtual void set_font(const vcl::Font&) override { assert(false && "not implemented"); }
6869
6870 virtual void set_entry_font(const vcl::Font& rFont) override { m_pEntry->set_font(rFont); }
6871
6872 virtual vcl::Font get_entry_font() override
6873 {
6874 Edit& rEntry = m_pEntry->getEntry();
6875 return rEntry.GetPointFont(*rEntry.GetOutDev());
6876 }
6877
6878 virtual void set_entry_placeholder_text(const OUString& rText) override
6879 {
6880 Edit& rEntry = m_pEntry->getEntry();
6881 rEntry.SetPlaceholderText(rText);
6882 }
6883
6884 virtual void set_entry_editable(bool bEditable) override
6885 {
6886 Edit& rEntry = m_pEntry->getEntry();
6887 rEntry.SetReadOnly(!bEditable);
6888 }
6889
6890 virtual void cut_entry_clipboard() override
6891 {
6892 Edit& rEntry = m_pEntry->getEntry();
6893 rEntry.Cut();
6894 }
6895
6896 virtual void copy_entry_clipboard() override
6897 {
6898 Edit& rEntry = m_pEntry->getEntry();
6899 rEntry.Copy();
6900 }
6901
6902 virtual void paste_entry_clipboard() override
6903 {
6904 Edit& rEntry = m_pEntry->getEntry();
6905 rEntry.Paste();
6906 }
6907
6908 virtual void grab_focus() override { m_xEntry->grab_focus(); }
6909
6910 virtual void connect_focus_in(const Link<Widget&, void>& rLink) override
6911 {
6912 m_xEntry->connect_focus_in(rLink);
6913 }
6914
6915 virtual void connect_focus_out(const Link<Widget&, void>& rLink) override
6916 {
6917 m_xEntry->connect_focus_out(rLink);
6918 }
6919
6920 virtual bool changed_by_direct_pick() const override { return m_bTreeChange; }
6921
6922 virtual void set_custom_renderer(bool /*bOn*/) override { assert(false && "not implemented"); }
6923
6924 virtual int get_max_mru_count() const override
6925 {
6926 assert(false && "not implemented");
6927 return 0;
6928 }
6929
6930 virtual void set_max_mru_count(int) override { assert(false && "not implemented"); }
6931
6932 virtual OUString get_mru_entries() const override
6933 {
6934 assert(false && "not implemented");
6935 return OUString();
6936 }
6937
6938 virtual void set_mru_entries(const OUString&) override { assert(false && "not implemented"); }
6939
6940 virtual void set_item_menu(const OUString&, weld::Menu*) override
6941 {
6942 assert(false && "not implemented");
6943 }
6944
6945 int get_menu_button_width() const override
6946 {
6947 assert(false && "not implemented");
6948 return 0;
6949 }
6950
6951 VclPtr<VirtualDevice> create_render_virtual_device() const override
6952 {
6953 return VclPtr<VirtualDevice>::Create();
6954 }
6955
6956 virtual ~SalInstanceEntryTreeView() override
6957 {
6958 Edit& rEntry = m_pEntry->getEntry();
6959 rEntry.RemoveEventListener(LINK(this, SalInstanceEntryTreeView, KeyPressListener));
6960 rEntry.SetAutocompleteHdl(Link<Edit&, void>());
6961 }
6962 };
6963
6964 IMPL_LINK(SalInstanceEntryTreeView, KeyPressListener, VclWindowEvent&, rEvent, void)
6965 {
6966 if (rEvent.GetId() != VclEventId::WindowKeyInput)
6967 return;
6968 const KeyEvent& rKeyEvent = *static_cast<KeyEvent*>(rEvent.GetData());
6969 sal_uInt16 nKeyCode = rKeyEvent.GetKeyCode().GetCode();
6970 if (!(nKeyCode == KEY_UP || nKeyCode == KEY_DOWN || nKeyCode == KEY_PAGEUP
6971 || nKeyCode == KEY_PAGEDOWN))
6972 return;
6973
6974 m_pTreeView->disable_notify_events();
6975 auto& rListBox = m_pTreeView->getTreeView();
6976 if (!rListBox.FirstSelected())
6977 {
6978 if (SvTreeListEntry* pEntry = rListBox.First())
6979 rListBox.Select(pEntry, true);
6980 }
6981 else
6982 rListBox.KeyInput(rKeyEvent);
6983 m_xEntry->set_text(m_xTreeView->get_selected_text());
6984 m_xEntry->select_region(0, -1);
6985 m_pTreeView->enable_notify_events();
6986 m_bTreeChange = true;
6987 m_pEntry->fire_signal_changed();
6988 m_bTreeChange = false;
6989 }
6990
6991 IMPL_LINK(SalInstanceEntryTreeView, AutocompleteHdl, Edit&, rEdit, void)
6992 {
6993 Selection aSel = rEdit.GetSelection();
6994
6995 OUString aFullText = rEdit.GetText();
6996 OUString aStartText = aFullText.copy(0, static_cast<sal_Int32>(aSel.Max()));
6997
6998 int nPos = -1;
6999 int nCount = m_xTreeView->n_children();
7000 for (int i = 0; i < nCount; ++i)
7001 {
7002 if (m_xTreeView->get_text(i).startsWithIgnoreAsciiCase(aStartText))
7003 {
7004 nPos = i;
7005 break;
7006 }
7007 }
7008
7009 m_xTreeView->select(nPos);
7010
7011 if (nPos != -1)
7012 {
7013 OUString aText = m_xTreeView->get_text(nPos);
7014 Selection aSelection(aText.getLength(), aStartText.getLength());
7015 rEdit.SetText(aText, aSelection);
7016 }
7017 }
7018
7019 SalInstancePopover::SalInstancePopover(DockingWindow* pPopover, SalInstanceBuilder* pBuilder,
7020 bool bTakeOwnership)
7021 : SalInstanceContainer(pPopover, pBuilder, bTakeOwnership)
7022 , m_xPopover(pPopover)
7023 {
7024 }
7025
7026 SalInstancePopover::~SalInstancePopover()
7027 {
7028 DockingManager* pDockingManager = vcl::Window::GetDockingManager();
7029 if (pDockingManager->IsInPopupMode(m_xPopover))
7030 ImplPopDown();
7031 }
7032
7033 void SalInstancePopover::popup_at_rect(weld::Widget* pParent, const tools::Rectangle& rRect,
7034 weld::Placement ePlace)
7035 {
7036 SalInstanceWidget* pVclWidget = dynamic_cast<SalInstanceWidget*>(pParent);
7037 assert(pVclWidget);
7038 vcl::Window* pWidget = pVclWidget->getWidget();
7039
7040 tools::Rectangle aRect;
7041 Point aPt = pWidget->OutputToScreenPixel(rRect.TopLeft());
7042 aRect.SetLeft(aPt.X());
7043 aRect.SetTop(aPt.Y());
7044 aPt = pWidget->OutputToScreenPixel(rRect.BottomRight());
7045 aRect.SetRight(aPt.X());
7046 aRect.SetBottom(aPt.Y());
7047
7048 FloatWinPopupFlags nFlags = FloatWinPopupFlags::GrabFocus | FloatWinPopupFlags::NoMouseUpClose;
7049 if (ePlace == weld::Placement::Under)
7050 nFlags = nFlags | FloatWinPopupFlags::Down;
7051 else
7052 nFlags = nFlags | FloatWinPopupFlags::Right;
7053
7054 m_xPopover->EnableDocking();
7055 DockingManager* pDockingManager = vcl::Window::GetDockingManager();
7056 pDockingManager->SetPopupModeEndHdl(m_xPopover,
7057 LINK(this, SalInstancePopover, PopupModeEndHdl));
7058 pDockingManager->StartPopupMode(m_xPopover, aRect, nFlags);
7059 }
7060
7061 void SalInstancePopover::ImplPopDown()
7062 {
7063 vcl::Window::GetDockingManager()->EndPopupMode(m_xPopover);
7064 m_xPopover->EnableDocking(false);
7065 signal_closed();
7066 }
7067
7068 void SalInstancePopover::popdown() { ImplPopDown(); }
7069
7070 void SalInstancePopover::resize_to_request()
7071 {
7072 ::resize_to_request(m_xPopover.get());
7073
7074 DockingManager* pDockingManager = vcl::Window::GetDockingManager();
7075 if (pDockingManager->IsInPopupMode(m_xPopover.get()))
7076 {
7077 Size aSize = m_xPopover->get_preferred_size();
7078 tools::Rectangle aRect = pDockingManager->GetPosSizePixel(m_xPopover.get());
7079 pDockingManager->SetPosSizePixel(m_xPopover.get(), aRect.Left(), aRect.Top(), aSize.Width(),
7080 aSize.Height(), PosSizeFlags::Size);
7081 }
7082 }
7083
7084 IMPL_LINK_NOARG(SalInstancePopover, PopupModeEndHdl, FloatingWindow*, void) { signal_closed(); }
7085
7086 SalInstanceBuilder::SalInstanceBuilder(vcl::Window* pParent, const OUString& rUIRoot,
7087 const OUString& rUIFile,
7088 const css::uno::Reference<css::frame::XFrame>& rFrame)
7089 : weld::Builder()
7090 , m_xBuilder(new VclBuilder(pParent, rUIRoot, rUIFile, {}, rFrame, false))
7091 {
7092 }
7093
7094 std::unique_ptr<weld::MessageDialog> SalInstanceBuilder::weld_message_dialog(const OUString& id)
7095 {
7096 MessageDialog* pMessageDialog = m_xBuilder->get<MessageDialog>(id);
7097 std::unique_ptr<weld::MessageDialog> pRet(
7098 pMessageDialog ? new SalInstanceMessageDialog(pMessageDialog, this, false) : nullptr);
7099 if (pMessageDialog)
7100 {
7101 assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed");
7102 m_aOwnedToplevel.set(pMessageDialog);
7103 m_xBuilder->drop_ownership(pMessageDialog);
7104 }
7105 return pRet;
7106 }
7107
7108 std::unique_ptr<weld::Dialog> SalInstanceBuilder::weld_dialog(const OUString& id)
7109 {
7110 Dialog* pDialog = m_xBuilder->get<Dialog>(id);
7111 std::unique_ptr<weld::Dialog> pRet(pDialog ? new SalInstanceDialog(pDialog, this, false)
7112 : nullptr);
7113 if (pDialog)
7114 {
7115 assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed");
7116 m_aOwnedToplevel.set(pDialog);
7117 m_xBuilder->drop_ownership(pDialog);
7118 }
7119 return pRet;
7120 }
7121
7122 std::unique_ptr<weld::Assistant> SalInstanceBuilder::weld_assistant(const OUString& id)
7123 {
7124 vcl::RoadmapWizard* pDialog = m_xBuilder->get<vcl::RoadmapWizard>(id);
7125 std::unique_ptr<weld::Assistant> pRet(pDialog ? new SalInstanceAssistant(pDialog, this, false)
7126 : nullptr);
7127 if (pDialog)
7128 {
7129 assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed");
7130 m_aOwnedToplevel.set(pDialog);
7131 m_xBuilder->drop_ownership(pDialog);
7132 }
7133 return pRet;
7134 }
7135
7136 std::unique_ptr<weld::Window> SalInstanceBuilder::create_screenshot_window()
7137 {
7138 assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed");
7139
7140 vcl::Window* pRoot = m_xBuilder->get_widget_root();
7141 if (SystemWindow* pWindow = dynamic_cast<SystemWindow*>(pRoot))
7142 {
7143 std::unique_ptr<weld::Window> xRet(new SalInstanceWindow(pWindow, this, false));
7144 m_aOwnedToplevel.set(pWindow);
7145 m_xBuilder->drop_ownership(pWindow);
7146 return xRet;
7147 }
7148
7149 VclPtrInstance<Dialog> xDialog(nullptr, WB_HIDE | WB_STDDIALOG | WB_SIZEABLE | WB_CLOSEABLE,
7150 Dialog::InitFlag::NoParent);
7151 xDialog->SetText(utl::ConfigManager::getProductName());
7152
7153 auto xContentArea = VclPtr<VclVBox>::Create(xDialog, false, 12);
7154 pRoot->SetParent(xContentArea);
7155 assert(pRoot == xContentArea->GetWindow(GetWindowType::FirstChild));
7156 xContentArea->Show();
7157 pRoot->Show();
7158 xDialog->SetHelpId(pRoot->GetHelpId());
7159
7160 m_aOwnedToplevel.set(xDialog);
7161
7162 return std::unique_ptr<weld::Dialog>(new SalInstanceDialog(xDialog, this, false));
7163 }
7164
7165 std::unique_ptr<weld::Widget> SalInstanceBuilder::weld_widget(const OUString& id)
7166 {
7167 vcl::Window* pWidget = m_xBuilder->get(id);
7168 return pWidget ? std::make_unique<SalInstanceWidget>(pWidget, this, false) : nullptr;
7169 }
7170
7171 std::unique_ptr<weld::Container> SalInstanceBuilder::weld_container(const OUString& id)
7172 {
7173 vcl::Window* pContainer = m_xBuilder->get(id);
7174 return pContainer ? std::make_unique<SalInstanceContainer>(pContainer, this, false) : nullptr;
7175 }
7176
7177 std::unique_ptr<weld::Box> SalInstanceBuilder::weld_box(const OUString& id)
7178 {
7179 VclBox* pContainer = m_xBuilder->get<VclBox>(id);
7180 return pContainer ? std::make_unique<SalInstanceBox>(pContainer, this, false) : nullptr;
7181 }
7182
7183 std::unique_ptr<weld::Paned> SalInstanceBuilder::weld_paned(const OUString& id)
7184 {
7185 VclPaned* pPaned = m_xBuilder->get<VclPaned>(id);
7186 return pPaned ? std::make_unique<SalInstancePaned>(pPaned, this, false) : nullptr;
7187 }
7188
7189 std::unique_ptr<weld::Frame> SalInstanceBuilder::weld_frame(const OUString& id)
7190 {
7191 VclFrame* pFrame = m_xBuilder->get<VclFrame>(id);
7192 std::unique_ptr<weld::Frame> pRet(pFrame ? new SalInstanceFrame(pFrame, this, false) : nullptr);
7193 return pRet;
7194 }
7195
7196 std::unique_ptr<weld::ScrolledWindow>
7197 SalInstanceBuilder::weld_scrolled_window(const OUString& id, bool bUserManagedScrolling)
7198 {
7199 VclScrolledWindow* pScrolledWindow = m_xBuilder->get<VclScrolledWindow>(id);
7200 return pScrolledWindow ? std::make_unique<SalInstanceScrolledWindow>(
7201 pScrolledWindow, this, false, bUserManagedScrolling)
7202 : nullptr;
7203 }
7204
7205 std::unique_ptr<weld::Notebook> SalInstanceBuilder::weld_notebook(const OUString& id)
7206 {
7207 vcl::Window* pNotebook = m_xBuilder->get(id);
7208 if (!pNotebook)
7209 return nullptr;
7210 if (pNotebook->GetType() == WindowType::TABCONTROL)
7211 return std::make_unique<SalInstanceNotebook>(static_cast<TabControl*>(pNotebook), this,
7212 false);
7213 if (pNotebook->GetType() == WindowType::VERTICALTABCONTROL)
7214 return std::make_unique<SalInstanceVerticalNotebook>(
7215 static_cast<VerticalTabControl*>(pNotebook), this, false);
7216 return nullptr;
7217 }
7218
7219 std::unique_ptr<weld::Button> SalInstanceBuilder::weld_button(const OUString& id)
7220 {
7221 Button* pButton = m_xBuilder->get<Button>(id);
7222 return pButton ? std::make_unique<SalInstanceButton>(pButton, this, false) : nullptr;
7223 }
7224
7225 std::unique_ptr<weld::MenuButton> SalInstanceBuilder::weld_menu_button(const OUString& id)
7226 {
7227 MenuButton* pButton = m_xBuilder->get<MenuButton>(id);
7228 return pButton ? std::make_unique<SalInstanceMenuButton>(pButton, this, false) : nullptr;
7229 }
7230
7231 std::unique_ptr<weld::MenuToggleButton>
7232 SalInstanceBuilder::weld_menu_toggle_button(const OUString& id)
7233 {
7234 MenuToggleButton* pButton = m_xBuilder->get<MenuToggleButton>(id);
7235 return pButton ? std::make_unique<SalInstanceMenuToggleButton>(pButton, this, false) : nullptr;
7236 }
7237
7238 std::unique_ptr<weld::LinkButton> SalInstanceBuilder::weld_link_button(const OUString& id)
7239 {
7240 FixedHyperlink* pButton = m_xBuilder->get<FixedHyperlink>(id);
7241 return pButton ? std::make_unique<SalInstanceLinkButton>(pButton, this, false) : nullptr;
7242 }
7243
7244 std::unique_ptr<weld::ToggleButton> SalInstanceBuilder::weld_toggle_button(const OUString& id)
7245 {
7246 PushButton* pToggleButton = m_xBuilder->get<PushButton>(id);
7247 return pToggleButton ? std::make_unique<SalInstanceToggleButton>(pToggleButton, this, false)
7248 : nullptr;
7249 }
7250
7251 std::unique_ptr<weld::RadioButton> SalInstanceBuilder::weld_radio_button(const OUString& id)
7252 {
7253 RadioButton* pRadioButton = m_xBuilder->get<RadioButton>(id);
7254 return pRadioButton ? std::make_unique<SalInstanceRadioButton>(pRadioButton, this, false)
7255 : nullptr;
7256 }
7257
7258 std::unique_ptr<weld::CheckButton> SalInstanceBuilder::weld_check_button(const OUString& id)
7259 {
7260 CheckBox* pCheckButton = m_xBuilder->get<CheckBox>(id);
7261 return pCheckButton ? std::make_unique<SalInstanceCheckButton>(pCheckButton, this, false)
7262 : nullptr;
7263 }
7264
7265 std::unique_ptr<weld::Scale> SalInstanceBuilder::weld_scale(const OUString& id)
7266 {
7267 Slider* pSlider = m_xBuilder->get<Slider>(id);
7268 return pSlider ? std::make_unique<SalInstanceScale>(pSlider, this, false) : nullptr;
7269 }
7270
7271 std::unique_ptr<weld::ProgressBar> SalInstanceBuilder::weld_progress_bar(const OUString& id)
7272 {
7273 ::ProgressBar* pProgress = m_xBuilder->get<::ProgressBar>(id);
7274 return pProgress ? std::make_unique<SalInstanceProgressBar>(pProgress, this, false) : nullptr;
7275 }
7276
7277 std::unique_ptr<weld::Spinner> SalInstanceBuilder::weld_spinner(const OUString& id)
7278 {
7279 Throbber* pThrobber = m_xBuilder->get<Throbber>(id);
7280 return pThrobber ? std::make_unique<SalInstanceSpinner>(pThrobber, this, false) : nullptr;
7281 }
7282
7283 std::unique_ptr<weld::Image> SalInstanceBuilder::weld_image(const OUString& id)
7284 {
7285 FixedImage* pImage = m_xBuilder->get<FixedImage>(id);
7286 return pImage ? std::make_unique<SalInstanceImage>(pImage, this, false) : nullptr;
7287 }
7288
7289 std::unique_ptr<weld::Calendar> SalInstanceBuilder::weld_calendar(const OUString& id)
7290 {
7291 Calendar* pCalendar = m_xBuilder->get<Calendar>(id);
7292 return pCalendar ? std::make_unique<SalInstanceCalendar>(pCalendar, this, false) : nullptr;
7293 }
7294
7295 std::unique_ptr<weld::Entry> SalInstanceBuilder::weld_entry(const OUString& id)
7296 {
7297 Edit* pEntry = m_xBuilder->get<Edit>(id);
7298 return pEntry ? std::make_unique<SalInstanceEntry>(pEntry, this, false) : nullptr;
7299 }
7300
7301 std::unique_ptr<weld::SpinButton> SalInstanceBuilder::weld_spin_button(const OUString& id)
7302 {
7303 FormattedField* pSpinButton = m_xBuilder->get<FormattedField>(id);
7304 return pSpinButton ? std::make_unique<SalInstanceSpinButton>(pSpinButton, this, false)
7305 : nullptr;
7306 }
7307
7308 std::unique_ptr<weld::MetricSpinButton>
7309 SalInstanceBuilder::weld_metric_spin_button(const OUString& id, FieldUnit eUnit)
7310 {
7311 std::unique_ptr<weld::SpinButton> xButton(weld_spin_button(id));
7312 if (xButton)
7313 {
7314 SalInstanceSpinButton& rButton = dynamic_cast<SalInstanceSpinButton&>(*xButton);
7315 rButton.SetUseThousandSep();
7316 }
7317 return std::make_unique<weld::MetricSpinButton>(std::move(xButton), eUnit);
7318 }
7319
7320 std::unique_ptr<weld::FormattedSpinButton>
7321 SalInstanceBuilder::weld_formatted_spin_button(const OUString& id)
7322 {
7323 FormattedField* pSpinButton = m_xBuilder->get<FormattedField>(id);
7324 return pSpinButton ? std::make_unique<SalInstanceFormattedSpinButton>(pSpinButton, this, false)
7325 : nullptr;
7326 }
7327
7328 std::unique_ptr<weld::ComboBox> SalInstanceBuilder::weld_combo_box(const OUString& id)
7329 {
7330 vcl::Window* pWidget = m_xBuilder->get(id);
7331 ::ComboBox* pComboBox = dynamic_cast<::ComboBox*>(pWidget);
7332 if (pComboBox)
7333 return std::make_unique<SalInstanceComboBoxWithEdit>(pComboBox, this, false);
7334 ListBox* pListBox = dynamic_cast<ListBox*>(pWidget);
7335 return pListBox ? std::make_unique<SalInstanceComboBoxWithoutEdit>(pListBox, this, false)
7336 : nullptr;
7337 }
7338
7339 std::unique_ptr<weld::EntryTreeView>
7340 SalInstanceBuilder::weld_entry_tree_view(const OUString& containerid, const OUString& entryid,
7341 const OUString& treeviewid)
7342 {
7343 vcl::Window* pContainer = m_xBuilder->get(containerid);
7344 return pContainer ? std::make_unique<SalInstanceEntryTreeView>(pContainer, this, false,
7345 weld_entry(entryid),
7346 weld_tree_view(treeviewid))
7347 : nullptr;
7348 }
7349
7350 std::unique_ptr<weld::TreeView> SalInstanceBuilder::weld_tree_view(const OUString& id)
7351 {
7352 SvTabListBox* pTreeView = m_xBuilder->get<SvTabListBox>(id);
7353 return pTreeView ? std::make_unique<SalInstanceTreeView>(pTreeView, this, false) : nullptr;
7354 }
7355
7356 std::unique_ptr<weld::IconView> SalInstanceBuilder::weld_icon_view(const OUString& id)
7357 {
7358 IconView* pIconView = m_xBuilder->get<IconView>(id);
7359 return pIconView ? std::make_unique<SalInstanceIconView>(pIconView, this, false) : nullptr;
7360 }
7361
7362 std::unique_ptr<weld::Label> SalInstanceBuilder::weld_label(const OUString& id)
7363 {
7364 Control* pLabel = m_xBuilder->get<Control>(id);
7365 return pLabel ? std::make_unique<SalInstanceLabel>(pLabel, this, false) : nullptr;
7366 }
7367
7368 std::unique_ptr<weld::TextView> SalInstanceBuilder::weld_text_view(const OUString& id)
7369 {
7370 VclMultiLineEdit* pTextView = m_xBuilder->get<VclMultiLineEdit>(id);
7371 return pTextView ? std::make_unique<SalInstanceTextView>(pTextView, this, false) : nullptr;
7372 }
7373
7374 std::unique_ptr<weld::Expander> SalInstanceBuilder::weld_expander(const OUString& id)
7375 {
7376 VclExpander* pExpander = m_xBuilder->get<VclExpander>(id);
7377 return pExpander ? std::make_unique<SalInstanceExpander>(pExpander, this, false) : nullptr;
7378 }
7379
7380 std::unique_ptr<weld::DrawingArea>
7381 SalInstanceBuilder::weld_drawing_area(const OUString& id, const a11yref& rA11yImpl,
7382 FactoryFunction pUITestFactoryFunction, void* pUserData)
7383 {
7384 VclDrawingArea* pDrawingArea = m_xBuilder->get<VclDrawingArea>(id);
7385 return pDrawingArea
7386 ? std::make_unique<SalInstanceDrawingArea>(pDrawingArea, this, rA11yImpl,
7387 pUITestFactoryFunction, pUserData, false)
7388 : nullptr;
7389 }
7390
7391 std::unique_ptr<weld::Menu> SalInstanceBuilder::weld_menu(const OUString& id)
7392 {
7393 PopupMenu* pMenu = m_xBuilder->get_menu(id);
7394 return pMenu ? std::make_unique<SalInstanceMenu>(pMenu, true) : nullptr;
7395 }
7396
7397 std::unique_ptr<weld::Popover> SalInstanceBuilder::weld_popover(const OUString& id)
7398 {
7399 DockingWindow* pDockingWindow = m_xBuilder->get<DockingWindow>(id);
7400 std::unique_ptr<weld::Popover> pRet(
7401 pDockingWindow ? new SalInstancePopover(pDockingWindow, this, false) : nullptr);
7402 if (pDockingWindow)
7403 {
7404 assert(!m_aOwnedToplevel && "only one toplevel per .ui allowed");
7405 m_aOwnedToplevel.set(pDockingWindow);
7406 m_xBuilder->drop_ownership(pDockingWindow);
7407 }
7408 return pRet;
7409 }
7410
7411 std::unique_ptr<weld::Toolbar> SalInstanceBuilder::weld_toolbar(const OUString& id)
7412 {
7413 ToolBox* pToolBox = m_xBuilder->get<ToolBox>(id);
7414 return pToolBox ? std::make_unique<SalInstanceToolbar>(pToolBox, this, false) : nullptr;
7415 }
7416
7417 std::unique_ptr<weld::Scrollbar> SalInstanceBuilder::weld_scrollbar(const OUString& id)
7418 {
7419 ScrollBar* pScrollbar = m_xBuilder->get<ScrollBar>(id);
7420 return pScrollbar ? std::make_unique<SalInstanceScrollbar>(pScrollbar, this, false) : nullptr;
7421 }
7422
7423 std::unique_ptr<weld::SizeGroup> SalInstanceBuilder::create_size_group()
7424 {
7425 return std::make_unique<SalInstanceSizeGroup>();
7426 }
7427
7428 OUString SalInstanceBuilder::get_current_page_help_id() const
7429 {
7430 vcl::Window* pCtrl = m_xBuilder->get("tabcontrol");
7431 if (!pCtrl)
7432 return {};
7433 VclPtr<vcl::Window> xTabPage;
7434 if (pCtrl->GetType() == WindowType::TABCONTROL)
7435 {
7436 TabControl* pTabCtrl = static_cast<TabControl*>(pCtrl);
7437 xTabPage = pTabCtrl->GetTabPage(pTabCtrl->GetCurPageId());
7438 }
7439 else if (pCtrl->GetType() == WindowType::VERTICALTABCONTROL)
7440 {
7441 VerticalTabControl* pTabCtrl = static_cast<VerticalTabControl*>(pCtrl);
7442 xTabPage = pTabCtrl->GetPage(pTabCtrl->GetCurPageId());
7443 }
7444 vcl::Window* pTabChild = xTabPage ? xTabPage->GetWindow(GetWindowType::FirstChild) : nullptr;
7445 pTabChild = pTabChild ? pTabChild->GetWindow(GetWindowType::FirstChild) : nullptr;
7446 if (pTabChild)
7447 return pTabChild->GetHelpId();
7448 return {};
7449 }
7450
7451 SalInstanceBuilder::~SalInstanceBuilder()
7452 {
7453 if (VclBuilderContainer* pOwnedToplevel
7454 = dynamic_cast<VclBuilderContainer*>(m_aOwnedToplevel.get()))
7455 pOwnedToplevel->m_pUIBuilder = std::move(m_xBuilder);
7456 else
7457 m_xBuilder.reset();
7458 m_aOwnedToplevel.disposeAndClear();
7459 }
7460
7461 std::unique_ptr<weld::Builder>
7462 SalInstance::CreateBuilder(weld::Widget* pParent, const OUString& rUIRoot, const OUString& rUIFile)
7463 {
7464 SalInstanceWidget* pParentInstance = dynamic_cast<SalInstanceWidget*>(pParent);
7465 vcl::Window* pParentWidget = pParentInstance ? pParentInstance->getWidget() : nullptr;
7466 return std::make_unique<SalInstanceBuilder>(pParentWidget, rUIRoot, rUIFile);
7467 }
7468
7469 std::unique_ptr<weld::Builder> SalInstance::CreateInterimBuilder(vcl::Window* pParent,
7470 const OUString& rUIRoot,
7471 const OUString& rUIFile, bool,
7472 sal_uInt64)
7473 {
7474 return std::make_unique<SalInstanceBuilder>(pParent, rUIRoot, rUIFile);
7475 }
7476
7477 void SalInstanceWindow::help()
7478 {
7479 //show help for widget with keyboard focus
7480 vcl::Window* pWidget = ImplGetSVData()->mpWinData->mpFocusWin;
7481 if (!pWidget)
7482 pWidget = m_xWindow;
7483 if (comphelper::LibreOfficeKit::isActive() && m_xWindow->GetFocusedWindow())
7484 pWidget = m_xWindow->GetFocusedWindow().get();
7485 OUString sHelpId = pWidget->GetHelpId();
7486 while (sHelpId.isEmpty())
7487 {
7488 pWidget = pWidget->GetParent();
7489 if (!pWidget)
7490 break;
7491 sHelpId = pWidget->GetHelpId();
7492 }
7493 std::unique_ptr<weld::Widget> xTemp(
7494 pWidget != m_xWindow ? new SalInstanceWidget(pWidget, m_pBuilder, false) : nullptr);
7495 weld::Widget* pSource = xTemp ? xTemp.get() : this;
7496 bool bRunNormalHelpRequest = !m_aHelpRequestHdl.IsSet() || m_aHelpRequestHdl.Call(*pSource);
7497 Help* pHelp = bRunNormalHelpRequest ? Application::GetHelp() : nullptr;
7498 if (!pHelp)
7499 return;
7500
7501 // tdf#126007, there's a nice fallback route for offline help where
7502 // the current page of a notebook will get checked when the help
7503 // button is pressed and there was no help for the dialog found.
7504 //
7505 // But for online help that route doesn't get taken, so bodge this here
7506 // by using the page help id if available and if the help button itself
7507 // was the original id
7508 if (m_pBuilder && sHelpId.endsWith("/help"))
7509 {
7510 OUString sPageId = m_pBuilder->get_current_page_help_id();
7511 if (!sPageId.isEmpty())
7512 sHelpId = sPageId;
7513 else
7514 {
7515 // tdf#129068 likewise the help for the wrapping dialog is less
7516 // helpful than the help for the content area could be
7517 vcl::Window* pContentArea = nullptr;
7518 if (::Dialog* pDialog = dynamic_cast<::Dialog*>(m_xWindow.get()))
7519 pContentArea = pDialog->get_content_area();
7520 if (pContentArea)
7521 {
7522 vcl::Window* pContentWidget = pContentArea->GetWindow(GetWindowType::LastChild);
7523 if (pContentWidget)
7524 sHelpId = pContentWidget->GetHelpId();
7525 }
7526 }
7527 }
7528 pHelp->Start(sHelpId, pSource);
7529 }
7530
7531 //iterate upwards through the hierarchy from this widgets through its parents
7532 //calling func with their helpid until func returns true or we run out of parents
7533 void SalInstanceWidget::help_hierarchy_foreach(const std::function<bool(const OUString&)>& func)
7534 {
7535 vcl::Window* pParent = m_xWidget;
7536 while ((pParent = pParent->GetParent()))
7537 {
7538 if (func(pParent->GetHelpId()))
7539 return;
7540 }
7541 }
7542
7543 weld::MessageDialog* SalInstance::CreateMessageDialog(weld::Widget* pParent,
7544 VclMessageType eMessageType,
7545 VclButtonsType eButtonsType,
7546 const OUString& rPrimaryMessage)
7547 {
7548 SalInstanceWidget* pParentInstance = dynamic_cast<SalInstanceWidget*>(pParent);
7549 SystemWindow* pParentWidget = pParentInstance ? pParentInstance->getSystemWindow() : nullptr;
7550 VclPtrInstance<MessageDialog> xMessageDialog(pParentWidget, rPrimaryMessage, eMessageType,
7551 eButtonsType);
7552 return new SalInstanceMessageDialog(xMessageDialog, nullptr, true);
7553 }
7554
7555 weld::Window* SalInstance::GetFrameWeld(const css::uno::Reference<css::awt::XWindow>& rWindow)
7556 {
7557 UnoWrapperBase* pWrapper = UnoWrapperBase::GetUnoWrapper();
7558 if (!pWrapper)
7559 return nullptr;
7560 VclPtr<vcl::Window> xWindow = pWrapper->GetWindow(rWindow);
7561 if (!xWindow)
7562 return nullptr;
7563 return xWindow->GetFrameWeld();
7564 }
7565
7566 weld::Window* SalFrame::GetFrameWeld() const
7567 {
7568 if (!m_xFrameWeld)
7569 {
7570 vcl::Window* pWindow = GetWindow();
7571 if (pWindow)
7572 {
7573 assert(pWindow == pWindow->GetFrameWindow());
7574 m_xFrameWeld.reset(new SalInstanceWindow(pWindow, nullptr, false));
7575 }
7576 }
7577 return m_xFrameWeld.get();
7578 }
7579
7580 Selection SalFrame::CalcDeleteSurroundingSelection(const OUString& rSurroundingText,
7581 sal_Int32 nCursorIndex, int nOffset, int nChars)
7582 {
7583 Selection aInvalid(SAL_MAX_UINT32, SAL_MAX_UINT32);
7584
7585 if (nCursorIndex == -1)
7586 return aInvalid;
7587
7588 if (nOffset > 0)
7589 {
7590 while (nOffset && nCursorIndex < rSurroundingText.getLength())
7591 {
7592 rSurroundingText.iterateCodePoints(&nCursorIndex, 1);
7593 --nOffset;
7594 }
7595 }
7596 else if (nOffset < 0)
7597 {
7598 while (nOffset && nCursorIndex > 0)
7599 {
7600 rSurroundingText.iterateCodePoints(&nCursorIndex, -1);
7601 ++nOffset;
7602 }
7603 }
7604
7605 if (nOffset)
7606 {
7607 SAL_WARN("vcl",
7608 "SalFrame::CalcDeleteSurroundingSelection, unable to move to offset: " << nOffset);
7609 return aInvalid;
7610 }
7611
7612 sal_Int32 nCursorEndIndex(nCursorIndex);
7613 sal_Int32 nCount(0);
7614 while (nCount < nChars && nCursorEndIndex < rSurroundingText.getLength())
7615 {
7616 rSurroundingText.iterateCodePoints(&nCursorEndIndex, 1);
7617 ++nCount;
7618 }
7619
7620 if (nCount != nChars)
7621 {
7622 SAL_WARN("vcl", "SalFrame::CalcDeleteSurroundingSelection, unable to select: "
7623 << nChars << " characters");
7624 return aInvalid;
7625 }
7626
7627 return Selection(nCursorIndex, nCursorEndIndex);
7628 }
7629
7630 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE