?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Simplify using designated initializers
[LibreOffice.git] / vcl / source / control / imp_listbox.cxx
blob45b84c7db4eabe596c390b0ebe4099bda16a3c73
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 <memory>
21
22 #include <vcl/svapp.hxx>
23 #include <vcl/settings.hxx>
24 #include <vcl/event.hxx>
25 #include <vcl/i18nhelp.hxx>
26 #include <vcl/naturalsort.hxx>
27 #include <vcl/vcllayout.hxx>
28 #include <vcl/toolkit/lstbox.hxx>
29 #include <vcl/toolkit/scrbar.hxx>
30
31 #include <listbox.hxx>
32 #include <svdata.hxx>
33 #include <window.h>
34
35 #include <com/sun/star/accessibility/AccessibleRole.hpp>
36
37 #include <sal/log.hxx>
38 #include <o3tl/safeint.hxx>
39 #include <o3tl/string_view.hxx>
40 #include <osl/diagnose.h>
41 #include <comphelper/string.hxx>
42 #include <comphelper/processfactory.hxx>
43
44 #include <limits>
45
46 #define MULTILINE_ENTRY_DRAW_FLAGS ( DrawTextFlags::WordBreak | DrawTextFlags::MultiLine | DrawTextFlags::VCenter )
47
48 using namespace ::com::sun::star;
49
50 constexpr tools::Long gnBorder = 1;
51
52 void ImplInitDropDownButton( PushButton* pButton )
53 {
54 pButton->SetSymbol( SymbolType::SPIN_DOWN );
55
56 if ( pButton->IsNativeControlSupported(ControlType::Listbox, ControlPart::Entire)
57 && ! pButton->IsNativeControlSupported(ControlType::Listbox, ControlPart::ButtonDown) )
58 pButton->SetBackground();
59 }
60
61 ImplEntryList::ImplEntryList( vcl::Window* pWindow )
62 {
63 mpWindow = pWindow;
64 mnLastSelected = LISTBOX_ENTRY_NOTFOUND;
65 mnSelectionAnchor = LISTBOX_ENTRY_NOTFOUND;
66 mnImages = 0;
67 mbCallSelectionChangedHdl = true;
68
69 mnMRUCount = 0;
70 mnMaxMRUCount = 0;
71 }
72
73 ImplEntryList::~ImplEntryList()
74 {
75 Clear();
76 }
77
78 void ImplEntryList::Clear()
79 {
80 mnImages = 0;
81 maEntries.clear();
82 }
83
84 void ImplEntryList::dispose()
85 {
86 Clear();
87 mpWindow.clear();
88 }
89
90 void ImplEntryList::SelectEntry( sal_Int32 nPos, bool bSelect )
91 {
92 if (0 <= nPos && o3tl::make_unsigned(nPos) < maEntries.size())
93 {
94 std::vector<std::unique_ptr<ImplEntryType> >::iterator iter = maEntries.begin()+nPos;
95
96 if ( ( (*iter)->mbIsSelected != bSelect ) &&
97 ( ( (*iter)->mnFlags & ListBoxEntryFlags::DisableSelection) == ListBoxEntryFlags::NONE ) )
98 {
99 (*iter)->mbIsSelected = bSelect;
100 if ( mbCallSelectionChangedHdl )
101 maSelectionChangedHdl.Call( nPos );
102 }
103 }
104 }
105
106 namespace
107 {
108 comphelper::string::NaturalStringSorter& GetSorter()
109 {
110 static comphelper::string::NaturalStringSorter gSorter(
111 ::comphelper::getProcessComponentContext(),
112 Application::GetSettings().GetLanguageTag().getLocale());
113 return gSorter;
114 };
115 }
116
117 namespace vcl
118 {
119 sal_Int32 NaturalSortCompare(const OUString &rA, const OUString &rB)
120 {
121 const comphelper::string::NaturalStringSorter &rSorter = GetSorter();
122 return rSorter.compare(rA, rB);
123 }
124 }
125
126 sal_Int32 ImplEntryList::InsertEntry( sal_Int32 nPos, ImplEntryType* pNewEntry, bool bSort )
127 {
128 assert(nPos >= 0);
129 assert(maEntries.size() < LISTBOX_MAX_ENTRIES);
130
131 if ( !!pNewEntry->maImage )
132 mnImages++;
133
134 sal_Int32 insPos = 0;
135 const sal_Int32 nEntriesSize = static_cast<sal_Int32>(maEntries.size());
136
137 if ( !bSort || maEntries.empty())
138 {
139 if (0 <= nPos && nPos < nEntriesSize)
140 {
141 insPos = nPos;
142 maEntries.insert( maEntries.begin() + nPos, std::unique_ptr<ImplEntryType>(pNewEntry) );
143 }
144 else
145 {
146 insPos = nEntriesSize;
147 maEntries.push_back(std::unique_ptr<ImplEntryType>(pNewEntry));
148 }
149 }
150 else
151 {
152 const comphelper::string::NaturalStringSorter &rSorter = GetSorter();
153
154 const OUString& rStr = pNewEntry->maStr;
155
156 ImplEntryType* pTemp = GetEntry( nEntriesSize-1 );
157
158 try
159 {
160 sal_Int32 nComp = rSorter.compare(rStr, pTemp->maStr);
161
162 // fast insert for sorted data
163 if ( nComp >= 0 )
164 {
165 insPos = nEntriesSize;
166 maEntries.push_back(std::unique_ptr<ImplEntryType>(pNewEntry));
167 }
168 else
169 {
170 pTemp = GetEntry( mnMRUCount );
171
172 nComp = rSorter.compare(rStr, pTemp->maStr);
173 if ( nComp <= 0 )
174 {
175 insPos = 0;
176 maEntries.insert(maEntries.begin(), std::unique_ptr<ImplEntryType>(pNewEntry));
177 }
178 else
179 {
180 sal_uLong nLow = mnMRUCount;
181 sal_uLong nHigh = maEntries.size()-1;
182 sal_Int32 nMid;
183
184 // binary search
185 do
186 {
187 nMid = static_cast<sal_Int32>((nLow + nHigh) / 2);
188 pTemp = GetEntry( nMid );
189
190 nComp = rSorter.compare(rStr, pTemp->maStr);
191
192 if ( nComp < 0 )
193 nHigh = nMid-1;
194 else
195 {
196 if ( nComp > 0 )
197 nLow = nMid + 1;
198 else
199 break;
200 }
201 }
202 while ( nLow <= nHigh );
203
204 if ( nComp >= 0 )
205 nMid++;
206
207 insPos = nMid;
208 maEntries.insert(maEntries.begin()+nMid, std::unique_ptr<ImplEntryType>(pNewEntry));
209 }
210 }
211 }
212 catch (uno::RuntimeException& )
213 {
214 // XXX this is arguable, if the exception occurred because pNewEntry is
215 // garbage you wouldn't insert it. If the exception occurred because the
216 // Collator implementation is garbage then give the user a chance to see
217 // his stuff
218 insPos = 0;
219 maEntries.insert(maEntries.begin(), std::unique_ptr<ImplEntryType>(pNewEntry));
220 }
221
222 }
223
224 return insPos;
225 }
226
227 void ImplEntryList::RemoveEntry( sal_Int32 nPos )
228 {
229 if (0 <= nPos && o3tl::make_unsigned(nPos) < maEntries.size())
230 {
231 std::vector<std::unique_ptr<ImplEntryType> >::iterator iter = maEntries.begin()+ nPos;
232
233 if ( !!(*iter)->maImage )
234 mnImages--;
235
236 maEntries.erase(iter);
237 }
238 }
239
240 sal_Int32 ImplEntryList::FindEntry( std::u16string_view rString, bool bSearchMRUArea ) const
241 {
242 const sal_Int32 nEntries = static_cast<sal_Int32>(maEntries.size());
243 for ( sal_Int32 n = bSearchMRUArea ? 0 : GetMRUCount(); n < nEntries; n++ )
244 {
245 OUString aComp( vcl::I18nHelper::filterFormattingChars( maEntries[n]->maStr ) );
246 if ( aComp == rString )
247 return n;
248 }
249 return LISTBOX_ENTRY_NOTFOUND;
250 }
251
252 sal_Int32 ImplEntryList::FindMatchingEntry( const OUString& rStr, sal_Int32 nStart, bool bLazy ) const
253 {
254 sal_Int32 nPos = LISTBOX_ENTRY_NOTFOUND;
255 sal_Int32 nEntryCount = GetEntryCount();
256
257 const vcl::I18nHelper& rI18nHelper = mpWindow->GetSettings().GetLocaleI18nHelper();
258 for ( sal_Int32 n = nStart; n < nEntryCount; )
259 {
260 ImplEntryType* pImplEntry = GetEntry( n );
261 bool bMatch;
262 if ( bLazy )
263 {
264 bMatch = rI18nHelper.MatchString( rStr, pImplEntry->maStr );
265 }
266 else
267 {
268 bMatch = pImplEntry->maStr.startsWith(rStr);
269 }
270 if ( bMatch )
271 {
272 nPos = n;
273 break;
274 }
275
276 n++;
277 }
278
279 return nPos;
280 }
281
282 tools::Long ImplEntryList::GetAddedHeight( sal_Int32 i_nEndIndex, sal_Int32 i_nBeginIndex ) const
283 {
284 tools::Long nHeight = 0;
285 sal_Int32 nStart = std::min(i_nEndIndex, i_nBeginIndex);
286 sal_Int32 nStop = std::max(i_nEndIndex, i_nBeginIndex);
287 sal_Int32 nEntryCount = GetEntryCount();
288 if( 0 <= nStop && nStop != LISTBOX_ENTRY_NOTFOUND && nEntryCount != 0 )
289 {
290 // sanity check
291 if( nStop > nEntryCount-1 )
292 nStop = nEntryCount-1;
293 if (nStart < 0)
294 nStart = 0;
295 else if( nStart > nEntryCount-1 )
296 nStart = nEntryCount-1;
297
298 sal_Int32 nIndex = nStart;
299 while( nIndex != LISTBOX_ENTRY_NOTFOUND && nIndex < nStop )
300 {
301 tools::Long nPosHeight = GetEntryPtr( nIndex )->getHeightWithMargin();
302 if (nHeight > ::std::numeric_limits<tools::Long>::max() - nPosHeight)
303 {
304 SAL_WARN( "vcl", "ImplEntryList::GetAddedHeight: truncated");
305 break;
306 }
307 nHeight += nPosHeight;
308 nIndex++;
309 }
310 }
311 else
312 nHeight = 0;
313 return i_nEndIndex > i_nBeginIndex ? nHeight : -nHeight;
314 }
315
316 tools::Long ImplEntryList::GetEntryHeight( sal_Int32 nPos ) const
317 {
318 ImplEntryType* pImplEntry = GetEntry( nPos );
319 return pImplEntry ? pImplEntry->getHeightWithMargin() : 0;
320 }
321
322 OUString ImplEntryList::GetEntryText( sal_Int32 nPos ) const
323 {
324 OUString aEntryText;
325 ImplEntryType* pImplEntry = GetEntry( nPos );
326 if ( pImplEntry )
327 aEntryText = pImplEntry->maStr;
328 return aEntryText;
329 }
330
331 bool ImplEntryList::HasEntryImage( sal_Int32 nPos ) const
332 {
333 bool bImage = false;
334 ImplEntryType* pImplEntry = GetEntry( nPos );
335 if ( pImplEntry )
336 bImage = !!pImplEntry->maImage;
337 return bImage;
338 }
339
340 Image ImplEntryList::GetEntryImage( sal_Int32 nPos ) const
341 {
342 Image aImage;
343 ImplEntryType* pImplEntry = GetEntry( nPos );
344 if ( pImplEntry )
345 aImage = pImplEntry->maImage;
346 return aImage;
347 }
348
349 void ImplEntryList::SetEntryData( sal_Int32 nPos, void* pNewData )
350 {
351 ImplEntryType* pImplEntry = GetEntry( nPos );
352 if ( pImplEntry )
353 pImplEntry->mpUserData = pNewData;
354 }
355
356 void* ImplEntryList::GetEntryData( sal_Int32 nPos ) const
357 {
358 ImplEntryType* pImplEntry = GetEntry( nPos );
359 return pImplEntry ? pImplEntry->mpUserData : nullptr;
360 }
361
362 void ImplEntryList::SetEntryFlags( sal_Int32 nPos, ListBoxEntryFlags nFlags )
363 {
364 ImplEntryType* pImplEntry = GetEntry( nPos );
365 if ( pImplEntry )
366 pImplEntry->mnFlags = nFlags;
367 }
368
369 sal_Int32 ImplEntryList::GetSelectedEntryCount() const
370 {
371 sal_Int32 nSelCount = 0;
372 for ( sal_Int32 n = GetEntryCount(); n; )
373 {
374 ImplEntryType* pImplEntry = GetEntry( --n );
375 if ( pImplEntry->mbIsSelected )
376 nSelCount++;
377 }
378 return nSelCount;
379 }
380
381 OUString ImplEntryList::GetSelectedEntry( sal_Int32 nIndex ) const
382 {
383 return GetEntryText( GetSelectedEntryPos( nIndex ) );
384 }
385
386 sal_Int32 ImplEntryList::GetSelectedEntryPos( sal_Int32 nIndex ) const
387 {
388 sal_Int32 nSelEntryPos = LISTBOX_ENTRY_NOTFOUND;
389 sal_Int32 nSel = 0;
390 sal_Int32 nEntryCount = GetEntryCount();
391
392 for ( sal_Int32 n = 0; n < nEntryCount; n++ )
393 {
394 ImplEntryType* pImplEntry = GetEntry( n );
395 if ( pImplEntry->mbIsSelected )
396 {
397 if ( nSel == nIndex )
398 {
399 nSelEntryPos = n;
400 break;
401 }
402 nSel++;
403 }
404 }
405
406 return nSelEntryPos;
407 }
408
409 bool ImplEntryList::IsEntryPosSelected( sal_Int32 nIndex ) const
410 {
411 ImplEntryType* pImplEntry = GetEntry( nIndex );
412 return pImplEntry && pImplEntry->mbIsSelected;
413 }
414
415 bool ImplEntryList::IsEntrySelectable( sal_Int32 nPos ) const
416 {
417 ImplEntryType* pImplEntry = GetEntry( nPos );
418 return pImplEntry == nullptr || ((pImplEntry->mnFlags & ListBoxEntryFlags::DisableSelection) == ListBoxEntryFlags::NONE);
419 }
420
421 sal_Int32 ImplEntryList::FindFirstSelectable( sal_Int32 nPos, bool bForward /* = true */ ) const
422 {
423 if( IsEntrySelectable( nPos ) )
424 return nPos;
425
426 if( bForward )
427 {
428 for( nPos = nPos + 1; nPos < GetEntryCount(); nPos++ )
429 {
430 if( IsEntrySelectable( nPos ) )
431 return nPos;
432 }
433 }
434 else
435 {
436 while( nPos )
437 {
438 nPos--;
439 if( IsEntrySelectable( nPos ) )
440 return nPos;
441 }
442 }
443
444 return LISTBOX_ENTRY_NOTFOUND;
445 }
446
447 ImplListBoxWindow::ImplListBoxWindow( vcl::Window* pParent, WinBits nWinStyle ) :
448 Control( pParent, 0 ),
449 maEntryList( this ),
450 maQuickSelectionEngine( *this )
451 {
452
453 mnTop = 0;
454 mnLeft = 0;
455 mnSelectModifier = 0;
456 mnUserDrawEntry = LISTBOX_ENTRY_NOTFOUND;
457 mbTrack = false;
458 mbTravelSelect = false;
459 mbTrackingSelect = false;
460 mbSelectionChanged = false;
461 mbMouseMoveSelect = false;
462 mbMulti = false;
463 mbGrabFocus = false;
464 mbUserDrawEnabled = false;
465 mbInUserDraw = false;
466 mbReadOnly = false;
467 mbHasFocusRect = false;
468 mbRight = ( nWinStyle & WB_RIGHT );
469 mbCenter = ( nWinStyle & WB_CENTER );
470 mbSimpleMode = ( nWinStyle & WB_SIMPLEMODE );
471 mbSort = ( nWinStyle & WB_SORT );
472 mbIsDropdown = ( nWinStyle & WB_DROPDOWN );
473 mbEdgeBlending = false;
474
475 mnCurrentPos = LISTBOX_ENTRY_NOTFOUND;
476 mnTrackingSaveSelection = LISTBOX_ENTRY_NOTFOUND;
477
478 GetOutDev()->SetLineColor();
479 SetTextFillColor();
480 SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetFieldColor() ) );
481
482 ApplySettings(*GetOutDev());
483 ImplCalcMetrics();
484 }
485
486 ImplListBoxWindow::~ImplListBoxWindow()
487 {
488 disposeOnce();
489 }
490
491 void ImplListBoxWindow::dispose()
492 {
493 maEntryList.dispose();
494 Control::dispose();
495 }
496
497 void ImplListBoxWindow::ApplySettings(vcl::RenderContext& rRenderContext)
498 {
499 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
500
501 ApplyControlFont(rRenderContext, rStyleSettings.GetFieldFont());
502 ApplyControlForeground(rRenderContext, rStyleSettings.GetListBoxWindowTextColor());
503
504 if (IsControlBackground())
505 rRenderContext.SetBackground(GetControlBackground());
506 else
507 rRenderContext.SetBackground(rStyleSettings.GetListBoxWindowBackgroundColor());
508 }
509
510 void ImplListBoxWindow::ImplCalcMetrics()
511 {
512 mnMaxWidth = 0;
513 mnMaxTxtWidth = 0;
514 mnMaxImgWidth = 0;
515 mnMaxImgTxtWidth= 0;
516 mnMaxImgHeight = 0;
517
518 mnTextHeight = static_cast<sal_uInt16>(GetTextHeight());
519 mnMaxTxtHeight = mnTextHeight + gnBorder;
520 mnMaxHeight = mnMaxTxtHeight;
521
522 if ( maUserItemSize.Height() > mnMaxHeight )
523 mnMaxHeight = static_cast<sal_uInt16>(maUserItemSize.Height());
524 if ( maUserItemSize.Width() > mnMaxWidth )
525 mnMaxWidth= static_cast<sal_uInt16>(maUserItemSize.Width());
526
527 for ( sal_Int32 n = maEntryList.GetEntryCount(); n; )
528 {
529 ImplEntryType* pEntry = maEntryList.GetMutableEntryPtr( --n );
530 ImplUpdateEntryMetrics( *pEntry );
531 }
532
533 if( mnCurrentPos != LISTBOX_ENTRY_NOTFOUND )
534 {
535 Size aSz( GetOutputSizePixel().Width(), maEntryList.GetEntryPtr( mnCurrentPos )->getHeightWithMargin() );
536 maFocusRect.SetSize( aSz );
537 }
538 }
539
540 void ImplListBoxWindow::Clear()
541 {
542 maEntryList.Clear();
543
544 mnMaxHeight = mnMaxTxtHeight;
545 mnMaxWidth = 0;
546 mnMaxTxtWidth = 0;
547 mnMaxImgTxtWidth= 0;
548 mnMaxImgWidth = 0;
549 mnMaxImgHeight = 0;
550 mnTop = 0;
551 mnLeft = 0;
552 ImplClearLayoutData();
553
554 mnCurrentPos = LISTBOX_ENTRY_NOTFOUND;
555 maQuickSelectionEngine.Reset();
556
557 Invalidate();
558 }
559
560 void ImplListBoxWindow::SetUserItemSize( const Size& rSz )
561 {
562 ImplClearLayoutData();
563 maUserItemSize = rSz;
564 ImplCalcMetrics();
565 }
566
567 namespace {
568
569 struct ImplEntryMetrics
570 {
571 bool bText;
572 bool bImage;
573 tools::Long nEntryWidth;
574 tools::Long nEntryHeight;
575 tools::Long nTextWidth;
576 tools::Long nImgWidth;
577 tools::Long nImgHeight;
578 };
579
580 }
581
582 tools::Long ImplEntryType::getHeightWithMargin() const
583 {
584 return mnHeight + ImplGetSVData()->maNWFData.mnListBoxEntryMargin;
585 }
586
587 SalLayoutGlyphs* ImplEntryType::GetTextGlyphs(const OutputDevice* pOutputDevice)
588 {
589 if (maStrGlyphs.IsValid())
590 // Use pre-calculated result.
591 return &maStrGlyphs;
592
593 std::unique_ptr<SalLayout> pLayout = pOutputDevice->ImplLayout(
594 maStr, 0, maStr.getLength(), Point(0, 0), 0, {}, {}, SalLayoutFlags::GlyphItemsOnly);
595 if (!pLayout)
596 return nullptr;
597
598 // Remember the calculation result.
599 maStrGlyphs = pLayout->GetGlyphs();
600
601 return &maStrGlyphs;
602 }
603
604 void ImplListBoxWindow::ImplUpdateEntryMetrics( ImplEntryType& rEntry )
605 {
606 ImplEntryMetrics aMetrics;
607 aMetrics.bText = !rEntry.maStr.isEmpty();
608 aMetrics.bImage = !!rEntry.maImage;
609 aMetrics.nEntryWidth = 0;
610 aMetrics.nEntryHeight = 0;
611 aMetrics.nTextWidth = 0;
612 aMetrics.nImgWidth = 0;
613 aMetrics.nImgHeight = 0;
614
615 if ( aMetrics.bText )
616 {
617 if( rEntry.mnFlags & ListBoxEntryFlags::MultiLine )
618 {
619 // multiline case
620 Size aCurSize( PixelToLogic( GetSizePixel() ) );
621 // set the current size to a large number
622 // GetTextRect should shrink it to the actual size
623 aCurSize.setHeight( 0x7fffff );
624 tools::Rectangle aTextRect( Point( 0, 0 ), aCurSize );
625 aTextRect = GetTextRect( aTextRect, rEntry.maStr, DrawTextFlags::WordBreak | DrawTextFlags::MultiLine );
626 aMetrics.nTextWidth = aTextRect.GetWidth();
627 if( aMetrics.nTextWidth > mnMaxTxtWidth )
628 mnMaxTxtWidth = aMetrics.nTextWidth;
629 aMetrics.nEntryWidth = mnMaxTxtWidth;
630 aMetrics.nEntryHeight = aTextRect.GetHeight() + gnBorder;
631 }
632 else
633 {
634 // normal single line case
635 const SalLayoutGlyphs* pGlyphs = rEntry.GetTextGlyphs(GetOutDev());
636 aMetrics.nTextWidth
637 = static_cast<sal_uInt16>(GetTextWidth(rEntry.maStr, 0, -1, nullptr, pGlyphs));
638 if( aMetrics.nTextWidth > mnMaxTxtWidth )
639 mnMaxTxtWidth = aMetrics.nTextWidth;
640 aMetrics.nEntryWidth = mnMaxTxtWidth;
641 aMetrics.nEntryHeight = mnTextHeight + gnBorder;
642 }
643 }
644 if ( aMetrics.bImage )
645 {
646 Size aImgSz = rEntry.maImage.GetSizePixel();
647 aMetrics.nImgWidth = static_cast<sal_uInt16>(CalcZoom( aImgSz.Width() ));
648 aMetrics.nImgHeight = static_cast<sal_uInt16>(CalcZoom( aImgSz.Height() ));
649
650 if( aMetrics.nImgWidth > mnMaxImgWidth )
651 mnMaxImgWidth = aMetrics.nImgWidth;
652 if( aMetrics.nImgHeight > mnMaxImgHeight )
653 mnMaxImgHeight = aMetrics.nImgHeight;
654
655 mnMaxImgTxtWidth = std::max( mnMaxImgTxtWidth, aMetrics.nTextWidth );
656 aMetrics.nEntryHeight = std::max( aMetrics.nImgHeight, aMetrics.nEntryHeight );
657
658 }
659
660 bool bIsUserDrawEnabled = IsUserDrawEnabled();
661 if (bIsUserDrawEnabled || aMetrics.bImage)
662 {
663 aMetrics.nEntryWidth = std::max( aMetrics.nImgWidth, maUserItemSize.Width() );
664 if (!bIsUserDrawEnabled && aMetrics.bText)
665 aMetrics.nEntryWidth += aMetrics.nTextWidth + IMG_TXT_DISTANCE;
666 aMetrics.nEntryHeight = std::max( std::max( mnMaxImgHeight, maUserItemSize.Height() ) + 2,
667 aMetrics.nEntryHeight );
668 }
669
670 if (!aMetrics.bText && !aMetrics.bImage && !bIsUserDrawEnabled)
671 {
672 // entries which have no (aka an empty) text, and no image,
673 // and are not user-drawn, should be shown nonetheless
674 aMetrics.nEntryHeight = mnTextHeight + gnBorder;
675 }
676
677 if ( aMetrics.nEntryWidth > mnMaxWidth )
678 mnMaxWidth = aMetrics.nEntryWidth;
679 if ( aMetrics.nEntryHeight > mnMaxHeight )
680 mnMaxHeight = aMetrics.nEntryHeight;
681
682 rEntry.mnHeight = aMetrics.nEntryHeight;
683 }
684
685 void ImplListBoxWindow::ImplCallSelect()
686 {
687 if ( !IsTravelSelect() && GetEntryList().GetMaxMRUCount() )
688 {
689 // Insert the selected entry as MRU, if not already first MRU
690 sal_Int32 nSelected = GetEntryList().GetSelectedEntryPos( 0 );
691 sal_Int32 nMRUCount = GetEntryList().GetMRUCount();
692 OUString aSelected = GetEntryList().GetEntryText( nSelected );
693 sal_Int32 nFirstMatchingEntryPos = GetEntryList().FindEntry( aSelected, true );
694 if ( nFirstMatchingEntryPos || !nMRUCount )
695 {
696 bool bSelectNewEntry = false;
697 if ( nFirstMatchingEntryPos < nMRUCount )
698 {
699 RemoveEntry( nFirstMatchingEntryPos );
700 nMRUCount--;
701 if ( nFirstMatchingEntryPos == nSelected )
702 bSelectNewEntry = true;
703 }
704 else if ( nMRUCount == GetEntryList().GetMaxMRUCount() )
705 {
706 RemoveEntry( nMRUCount - 1 );
707 nMRUCount--;
708 }
709
710 ImplClearLayoutData();
711
712 ImplEntryType* pNewEntry = new ImplEntryType( aSelected );
713 pNewEntry->mbIsSelected = bSelectNewEntry;
714 GetEntryList().InsertEntry( 0, pNewEntry, false );
715 ImplUpdateEntryMetrics( *pNewEntry );
716 GetEntryList().SetMRUCount( ++nMRUCount );
717 SetSeparatorPos( nMRUCount ? nMRUCount-1 : 0 );
718 maMRUChangedHdl.Call( nullptr );
719 }
720 }
721
722 maSelectHdl.Call( nullptr );
723 mbSelectionChanged = false;
724 }
725
726 sal_Int32 ImplListBoxWindow::InsertEntry(sal_Int32 nPos, ImplEntryType* pNewEntry, bool bSort)
727 {
728 assert(nPos >= 0);
729 assert(maEntryList.GetEntryCount() < LISTBOX_MAX_ENTRIES);
730
731 ImplClearLayoutData();
732 sal_Int32 nNewPos = maEntryList.InsertEntry( nPos, pNewEntry, bSort );
733
734 if( GetStyle() & WB_WORDBREAK )
735 pNewEntry->mnFlags |= ListBoxEntryFlags::MultiLine;
736
737 ImplUpdateEntryMetrics( *pNewEntry );
738 return nNewPos;
739 }
740
741 sal_Int32 ImplListBoxWindow::InsertEntry( sal_Int32 nPos, ImplEntryType* pNewEntry )
742 {
743 return InsertEntry(nPos, pNewEntry, mbSort);
744 }
745
746 void ImplListBoxWindow::RemoveEntry( sal_Int32 nPos )
747 {
748 ImplClearLayoutData();
749 maEntryList.RemoveEntry( nPos );
750 if( mnCurrentPos >= maEntryList.GetEntryCount() )
751 mnCurrentPos = LISTBOX_ENTRY_NOTFOUND;
752 ImplCalcMetrics();
753 }
754
755 void ImplListBoxWindow::SetEntryFlags( sal_Int32 nPos, ListBoxEntryFlags nFlags )
756 {
757 maEntryList.SetEntryFlags( nPos, nFlags );
758 ImplEntryType* pEntry = maEntryList.GetMutableEntryPtr( nPos );
759 if( pEntry )
760 ImplUpdateEntryMetrics( *pEntry );
761 }
762
763 void ImplListBoxWindow::ImplShowFocusRect()
764 {
765 if ( mbHasFocusRect )
766 HideFocus();
767 ShowFocus( maFocusRect );
768 mbHasFocusRect = true;
769 }
770
771 void ImplListBoxWindow::ImplHideFocusRect()
772 {
773 if ( mbHasFocusRect )
774 {
775 HideFocus();
776 mbHasFocusRect = false;
777 }
778 }
779
780 sal_Int32 ImplListBoxWindow::GetEntryPosForPoint( const Point& rPoint ) const
781 {
782 tools::Long nY = gnBorder;
783
784 sal_Int32 nSelect = mnTop;
785 const ImplEntryType* pEntry = maEntryList.GetEntryPtr( nSelect );
786 while (pEntry)
787 {
788 tools::Long nEntryHeight = pEntry->getHeightWithMargin();
789 if (rPoint.Y() <= nEntryHeight + nY)
790 break;
791 nY += nEntryHeight;
792 pEntry = maEntryList.GetEntryPtr( ++nSelect );
793 }
794 if( pEntry == nullptr )
795 nSelect = LISTBOX_ENTRY_NOTFOUND;
796
797 return nSelect;
798 }
799
800 bool ImplListBoxWindow::IsVisible( sal_Int32 i_nEntry ) const
801 {
802 bool bRet = false;
803
804 if( i_nEntry >= mnTop )
805 {
806 if( maEntryList.GetAddedHeight( i_nEntry, mnTop ) <
807 PixelToLogic( GetSizePixel() ).Height() )
808 {
809 bRet = true;
810 }
811 }
812
813 return bRet;
814 }
815
816 tools::Long ImplListBoxWindow::GetEntryHeightWithMargin() const
817 {
818 tools::Long nMargin = ImplGetSVData()->maNWFData.mnListBoxEntryMargin;
819 return mnMaxHeight + nMargin;
820 }
821
822 sal_Int32 ImplListBoxWindow::GetLastVisibleEntry() const
823 {
824 sal_Int32 nPos = mnTop;
825 tools::Long nWindowHeight = GetSizePixel().Height();
826 sal_Int32 nCount = maEntryList.GetEntryCount();
827 tools::Long nDiff;
828 for( nDiff = 0; nDiff < nWindowHeight && nPos < nCount; nDiff = maEntryList.GetAddedHeight( nPos, mnTop ) )
829 nPos++;
830
831 if( nDiff > nWindowHeight && nPos > mnTop )
832 nPos--;
833
834 if( nPos >= nCount )
835 nPos = nCount-1;
836
837 return nPos;
838 }
839
840 void ImplListBoxWindow::MouseButtonDown( const MouseEvent& rMEvt )
841 {
842 mbMouseMoveSelect = false; // only till the first MouseButtonDown
843 maQuickSelectionEngine.Reset();
844
845 if ( !IsReadOnly() )
846 {
847 if( rMEvt.GetClicks() == 1 )
848 {
849 sal_Int32 nSelect = GetEntryPosForPoint( rMEvt.GetPosPixel() );
850 if( nSelect != LISTBOX_ENTRY_NOTFOUND )
851 {
852 if ( !mbMulti && GetEntryList().GetSelectedEntryCount() )
853 mnTrackingSaveSelection = GetEntryList().GetSelectedEntryPos( 0 );
854 else
855 mnTrackingSaveSelection = LISTBOX_ENTRY_NOTFOUND;
856
857 mnCurrentPos = nSelect;
858 mbTrackingSelect = true;
859 bool bCurPosChange = (mnCurrentPos != nSelect);
860 (void)SelectEntries( nSelect, LET_MBDOWN, rMEvt.IsShift(), rMEvt.IsMod1() ,bCurPosChange);
861 mbTrackingSelect = false;
862 if ( mbGrabFocus )
863 GrabFocus();
864
865 StartTracking( StartTrackingFlags::ScrollRepeat );
866 }
867 }
868 if( rMEvt.GetClicks() == 2 )
869 {
870 maDoubleClickHdl.Call( this );
871 }
872 }
873 else // if ( mbGrabFocus )
874 {
875 GrabFocus();
876 }
877 }
878
879 void ImplListBoxWindow::MouseMove( const MouseEvent& rMEvt )
880 {
881 if (rMEvt.IsLeaveWindow() || mbMulti || !IsMouseMoveSelect() || !maEntryList.GetEntryCount())
882 return;
883
884 tools::Rectangle aRect( Point(), GetOutputSizePixel() );
885 if( !aRect.Contains( rMEvt.GetPosPixel() ) )
886 return;
887
888 if ( IsMouseMoveSelect() )
889 {
890 sal_Int32 nSelect = GetEntryPosForPoint( rMEvt.GetPosPixel() );
891 if( nSelect == LISTBOX_ENTRY_NOTFOUND )
892 nSelect = maEntryList.GetEntryCount() - 1;
893 nSelect = std::min( nSelect, GetLastVisibleEntry() );
894 nSelect = std::min( nSelect, static_cast<sal_Int32>( maEntryList.GetEntryCount() - 1 ) );
895 // Select only visible Entries with MouseMove, otherwise Tracking...
896 if ( IsVisible( nSelect ) &&
897 maEntryList.IsEntrySelectable( nSelect ) &&
898 ( ( nSelect != mnCurrentPos ) || !GetEntryList().GetSelectedEntryCount() || ( nSelect != GetEntryList().GetSelectedEntryPos( 0 ) ) ) )
899 {
900 mbTrackingSelect = true;
901 if ( SelectEntries( nSelect, LET_TRACKING ) )
902 {
903 // When list box selection change by mouse move, notify
904 // VclEventId::ListboxSelect vcl event.
905 maListItemSelectHdl.Call(nullptr);
906 }
907 mbTrackingSelect = false;
908 }
909 }
910
911 // if the DD button was pressed and someone moved into the ListBox
912 // with the mouse button pressed...
913 if ( rMEvt.IsLeft() && !rMEvt.IsSynthetic() )
914 {
915 if ( !mbMulti && GetEntryList().GetSelectedEntryCount() )
916 mnTrackingSaveSelection = GetEntryList().GetSelectedEntryPos( 0 );
917 else
918 mnTrackingSaveSelection = LISTBOX_ENTRY_NOTFOUND;
919
920 StartTracking( StartTrackingFlags::ScrollRepeat );
921 }
922 }
923
924 void ImplListBoxWindow::DeselectAll()
925 {
926 while ( GetEntryList().GetSelectedEntryCount() )
927 {
928 sal_Int32 nS = GetEntryList().GetSelectedEntryPos( 0 );
929 SelectEntry( nS, false );
930 }
931 }
932
933 void ImplListBoxWindow::SelectEntry( sal_Int32 nPos, bool bSelect )
934 {
935 if( (maEntryList.IsEntryPosSelected( nPos ) == bSelect) || !maEntryList.IsEntrySelectable( nPos ) )
936 return;
937
938 ImplHideFocusRect();
939 if( bSelect )
940 {
941 if( !mbMulti )
942 {
943 // deselect the selected entry
944 sal_Int32 nDeselect = GetEntryList().GetSelectedEntryPos( 0 );
945 if( nDeselect != LISTBOX_ENTRY_NOTFOUND )
946 {
947 //SelectEntryPos( nDeselect, false );
948 GetEntryList().SelectEntry( nDeselect, false );
949 if (IsUpdateMode() && IsReallyVisible())
950 Invalidate();
951 }
952 }
953 maEntryList.SelectEntry( nPos, true );
954 mnCurrentPos = nPos;
955 if ( ( nPos != LISTBOX_ENTRY_NOTFOUND ) && IsUpdateMode() )
956 {
957 Invalidate();
958 if ( !IsVisible( nPos ) )
959 {
960 ImplClearLayoutData();
961 sal_Int32 nVisibleEntries = GetLastVisibleEntry()-mnTop;
962 if ( !nVisibleEntries || !IsReallyVisible() || ( nPos < GetTopEntry() ) )
963 {
964 Resize();
965 ShowProminentEntry( nPos );
966 }
967 else
968 {
969 ShowProminentEntry( nPos );
970 }
971 }
972 }
973 }
974 else
975 {
976 maEntryList.SelectEntry( nPos, false );
977 Invalidate();
978 }
979 mbSelectionChanged = true;
980 }
981
982 bool ImplListBoxWindow::SelectEntries( sal_Int32 nSelect, LB_EVENT_TYPE eLET, bool bShift, bool bCtrl, bool bSelectPosChange /*=FALSE*/ )
983 {
984 bool bSelectionChanged = false;
985
986 if( IsEnabled() && maEntryList.IsEntrySelectable( nSelect ) )
987 {
988 bool bFocusChanged = false;
989
990 // here (Single-ListBox) only one entry can be deselected
991 if( !mbMulti )
992 {
993 sal_Int32 nDeselect = maEntryList.GetSelectedEntryPos( 0 );
994 if( nSelect != nDeselect )
995 {
996 SelectEntry( nSelect, true );
997 maEntryList.SetLastSelected( nSelect );
998 bFocusChanged = true;
999 bSelectionChanged = true;
1000 }
1001 }
1002 // MultiListBox without Modifier
1003 else if( mbSimpleMode && !bCtrl && !bShift )
1004 {
1005 sal_Int32 nEntryCount = maEntryList.GetEntryCount();
1006 for ( sal_Int32 nPos = 0; nPos < nEntryCount; nPos++ )
1007 {
1008 bool bSelect = nPos == nSelect;
1009 if ( maEntryList.IsEntryPosSelected( nPos ) != bSelect )
1010 {
1011 SelectEntry( nPos, bSelect );
1012 bFocusChanged = true;
1013 bSelectionChanged = true;
1014 }
1015 }
1016 maEntryList.SetLastSelected( nSelect );
1017 maEntryList.SetSelectionAnchor( nSelect );
1018 }
1019 // MultiListBox only with CTRL/SHIFT or not in SimpleMode
1020 else if( ( !mbSimpleMode /* && !bShift */ ) || ( mbSimpleMode && ( bCtrl || bShift ) ) )
1021 {
1022 // Space for selection change
1023 if( !bShift && ( ( eLET == LET_KEYSPACE ) || ( eLET == LET_MBDOWN ) ) )
1024 {
1025 bool bSelect = !maEntryList.IsEntryPosSelected( nSelect );
1026 SelectEntry( nSelect, bSelect );
1027 maEntryList.SetLastSelected( nSelect );
1028 maEntryList.SetSelectionAnchor( nSelect );
1029 if ( !maEntryList.IsEntryPosSelected( nSelect ) )
1030 maEntryList.SetSelectionAnchor( LISTBOX_ENTRY_NOTFOUND );
1031 bFocusChanged = true;
1032 bSelectionChanged = true;
1033 }
1034 else if( ( ( eLET == LET_TRACKING ) && ( nSelect != mnCurrentPos ) ) ||
1035 ( bShift && ( ( eLET == LET_KEYMOVE ) || ( eLET == LET_MBDOWN ) ) ) )
1036 {
1037 mnCurrentPos = nSelect;
1038 bFocusChanged = true;
1039
1040 sal_Int32 nAnchor = maEntryList.GetSelectionAnchor();
1041 if( ( nAnchor == LISTBOX_ENTRY_NOTFOUND ) && maEntryList.GetSelectedEntryCount() )
1042 {
1043 nAnchor = maEntryList.GetSelectedEntryPos( maEntryList.GetSelectedEntryCount() - 1 );
1044 }
1045 if( nAnchor != LISTBOX_ENTRY_NOTFOUND )
1046 {
1047 // All entries from Anchor to nSelect have to be selected
1048 sal_Int32 nStart = std::min( nSelect, nAnchor );
1049 sal_Int32 nEnd = std::max( nSelect, nAnchor );
1050 for ( sal_Int32 n = nStart; n <= nEnd; n++ )
1051 {
1052 if ( !maEntryList.IsEntryPosSelected( n ) )
1053 {
1054 SelectEntry( n, true );
1055 bSelectionChanged = true;
1056 }
1057 }
1058
1059 // if appropriate some more has to be deselected...
1060 sal_Int32 nLast = maEntryList.GetLastSelected();
1061 if ( nLast != LISTBOX_ENTRY_NOTFOUND )
1062 {
1063 if ( ( nLast > nSelect ) && ( nLast > nAnchor ) )
1064 {
1065 for ( sal_Int32 n = nSelect+1; n <= nLast; n++ )
1066 {
1067 if ( maEntryList.IsEntryPosSelected( n ) )
1068 {
1069 SelectEntry( n, false );
1070 bSelectionChanged = true;
1071 }
1072 }
1073 }
1074 else if ( ( nLast < nSelect ) && ( nLast < nAnchor ) )
1075 {
1076 for ( sal_Int32 n = nLast; n < nSelect; n++ )
1077 {
1078 if ( maEntryList.IsEntryPosSelected( n ) )
1079 {
1080 SelectEntry( n, false );
1081 bSelectionChanged = true;
1082 }
1083 }
1084 }
1085 }
1086 maEntryList.SetLastSelected( nSelect );
1087 }
1088 }
1089 else if( eLET != LET_TRACKING )
1090 {
1091 ImplHideFocusRect();
1092 Invalidate();
1093 bFocusChanged = true;
1094 }
1095 }
1096 else if( bShift )
1097 {
1098 bFocusChanged = true;
1099 }
1100
1101 if( bSelectionChanged )
1102 mbSelectionChanged = true;
1103
1104 if( bFocusChanged )
1105 {
1106 tools::Long nHeightDiff = maEntryList.GetAddedHeight( nSelect, mnTop );
1107 maFocusRect.SetPos( Point( 0, nHeightDiff ) );
1108 Size aSz( maFocusRect.GetWidth(),
1109 maEntryList.GetEntryHeight( nSelect ) );
1110 maFocusRect.SetSize( aSz );
1111 if( HasFocus() )
1112 ImplShowFocusRect();
1113 if (bSelectPosChange)
1114 {
1115 maFocusHdl.Call(nSelect);
1116 }
1117 }
1118 ImplClearLayoutData();
1119 }
1120 return bSelectionChanged;
1121 }
1122
1123 void ImplListBoxWindow::Tracking( const TrackingEvent& rTEvt )
1124 {
1125 tools::Rectangle aRect( Point(), GetOutputSizePixel() );
1126 bool bInside = aRect.Contains( rTEvt.GetMouseEvent().GetPosPixel() );
1127
1128 if( rTEvt.IsTrackingCanceled() || rTEvt.IsTrackingEnded() ) // MouseButtonUp
1129 {
1130 if ( bInside && !rTEvt.IsTrackingCanceled() )
1131 {
1132 mnSelectModifier = rTEvt.GetMouseEvent().GetModifier();
1133 ImplCallSelect();
1134 }
1135 else
1136 {
1137 maCancelHdl.Call( nullptr );
1138 if ( !mbMulti )
1139 {
1140 mbTrackingSelect = true;
1141 SelectEntry( mnTrackingSaveSelection, true );
1142 mbTrackingSelect = false;
1143 if ( mnTrackingSaveSelection != LISTBOX_ENTRY_NOTFOUND )
1144 {
1145 tools::Long nHeightDiff = maEntryList.GetAddedHeight( mnCurrentPos, mnTop );
1146 maFocusRect.SetPos( Point( 0, nHeightDiff ) );
1147 Size aSz( maFocusRect.GetWidth(),
1148 maEntryList.GetEntryHeight( mnCurrentPos ) );
1149 maFocusRect.SetSize( aSz );
1150 ImplShowFocusRect();
1151 }
1152 }
1153 }
1154
1155 mbTrack = false;
1156 }
1157 else
1158 {
1159 bool bTrackOrQuickClick = mbTrack;
1160 if( !mbTrack )
1161 {
1162 if ( bInside )
1163 {
1164 mbTrack = true;
1165 }
1166
1167 // this case only happens, if the mouse button is pressed very briefly
1168 if( rTEvt.IsTrackingEnded() && mbTrack )
1169 {
1170 bTrackOrQuickClick = true;
1171 mbTrack = false;
1172 }
1173 }
1174
1175 if( bTrackOrQuickClick )
1176 {
1177 MouseEvent aMEvt = rTEvt.GetMouseEvent();
1178 Point aPt( aMEvt.GetPosPixel() );
1179 bool bShift = aMEvt.IsShift();
1180 bool bCtrl = aMEvt.IsMod1();
1181
1182 sal_Int32 nSelect = LISTBOX_ENTRY_NOTFOUND;
1183 if( aPt.Y() < 0 )
1184 {
1185 if ( mnCurrentPos != LISTBOX_ENTRY_NOTFOUND )
1186 {
1187 nSelect = mnCurrentPos ? ( mnCurrentPos - 1 ) : 0;
1188 if( nSelect < mnTop )
1189 SetTopEntry( mnTop-1 );
1190 }
1191 }
1192 else if( aPt.Y() > GetOutputSizePixel().Height() )
1193 {
1194 if ( mnCurrentPos != LISTBOX_ENTRY_NOTFOUND )
1195 {
1196 nSelect = std::min( static_cast<sal_Int32>(mnCurrentPos+1), static_cast<sal_Int32>(maEntryList.GetEntryCount()-1) );
1197 if( nSelect >= GetLastVisibleEntry() )
1198 SetTopEntry( mnTop+1 );
1199 }
1200 }
1201 else
1202 {
1203 nSelect = static_cast<sal_Int32>( ( aPt.Y() + gnBorder ) / mnMaxHeight ) + mnTop;
1204 nSelect = std::min( nSelect, GetLastVisibleEntry() );
1205 nSelect = std::min( nSelect, static_cast<sal_Int32>( maEntryList.GetEntryCount() - 1 ) );
1206 }
1207
1208 if ( bInside )
1209 {
1210 if ( ( nSelect != mnCurrentPos ) || !GetEntryList().GetSelectedEntryCount() )
1211 {
1212 mbTrackingSelect = true;
1213 SelectEntries(nSelect, LET_TRACKING, bShift, bCtrl);
1214 mbTrackingSelect = false;
1215 }
1216 }
1217 else
1218 {
1219 if ( !mbMulti && GetEntryList().GetSelectedEntryCount() )
1220 {
1221 mbTrackingSelect = true;
1222 SelectEntry( GetEntryList().GetSelectedEntryPos( 0 ), false );
1223 mbTrackingSelect = false;
1224 }
1225 }
1226 mnCurrentPos = nSelect;
1227 if ( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
1228 {
1229 ImplHideFocusRect();
1230 }
1231 else
1232 {
1233 tools::Long nHeightDiff = maEntryList.GetAddedHeight( mnCurrentPos, mnTop );
1234 maFocusRect.SetPos( Point( 0, nHeightDiff ) );
1235 Size aSz( maFocusRect.GetWidth(), maEntryList.GetEntryHeight( mnCurrentPos ) );
1236 maFocusRect.SetSize( aSz );
1237 ImplShowFocusRect();
1238 }
1239 }
1240 }
1241 }
1242
1243 void ImplListBoxWindow::KeyInput( const KeyEvent& rKEvt )
1244 {
1245 if( !ProcessKeyInput( rKEvt ) )
1246 Control::KeyInput( rKEvt );
1247 }
1248
1249 bool ImplListBoxWindow::ProcessKeyInput( const KeyEvent& rKEvt )
1250 {
1251 // entry to be selected
1252 sal_Int32 nSelect = LISTBOX_ENTRY_NOTFOUND;
1253 LB_EVENT_TYPE eLET = LET_KEYMOVE;
1254
1255 vcl::KeyCode aKeyCode = rKEvt.GetKeyCode();
1256
1257 bool bShift = aKeyCode.IsShift();
1258 bool bCtrl = aKeyCode.IsMod1() || aKeyCode.IsMod3();
1259 bool bMod2 = aKeyCode.IsMod2();
1260 bool bDone = false;
1261 bool bHandleKey = false;
1262
1263 switch( aKeyCode.GetCode() )
1264 {
1265 case KEY_UP:
1266 {
1267 if ( IsReadOnly() )
1268 {
1269 if ( GetTopEntry() )
1270 SetTopEntry( GetTopEntry()-1 );
1271 }
1272 else if ( !bMod2 )
1273 {
1274 if( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
1275 {
1276 nSelect = maEntryList.FindFirstSelectable( 0 );
1277 }
1278 else if ( mnCurrentPos )
1279 {
1280 // search first selectable above the current position
1281 nSelect = maEntryList.FindFirstSelectable( mnCurrentPos - 1, false );
1282 }
1283
1284 if( ( nSelect != LISTBOX_ENTRY_NOTFOUND ) && ( nSelect < mnTop ) )
1285 SetTopEntry( mnTop-1 );
1286
1287 bDone = true;
1288 }
1289 maQuickSelectionEngine.Reset();
1290 }
1291 break;
1292
1293 case KEY_DOWN:
1294 {
1295 if ( IsReadOnly() )
1296 {
1297 SetTopEntry( GetTopEntry()+1 );
1298 }
1299 else if ( !bMod2 )
1300 {
1301 if( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
1302 {
1303 nSelect = maEntryList.FindFirstSelectable( 0 );
1304 }
1305 else if ( (mnCurrentPos+1) < maEntryList.GetEntryCount() )
1306 {
1307 // search first selectable below the current position
1308 nSelect = maEntryList.FindFirstSelectable( mnCurrentPos + 1 );
1309 }
1310
1311 if( ( nSelect != LISTBOX_ENTRY_NOTFOUND ) && ( nSelect >= GetLastVisibleEntry() ) )
1312 SetTopEntry( mnTop+1 );
1313
1314 bDone = true;
1315 }
1316 maQuickSelectionEngine.Reset();
1317 }
1318 break;
1319
1320 case KEY_PAGEUP:
1321 {
1322 if ( IsReadOnly() )
1323 {
1324 sal_Int32 nCurVis = GetLastVisibleEntry() - mnTop +1;
1325 SetTopEntry( ( mnTop > nCurVis ) ?
1326 (mnTop-nCurVis) : 0 );
1327 }
1328 else if ( !bCtrl && !bMod2 )
1329 {
1330 if( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
1331 {
1332 nSelect = maEntryList.FindFirstSelectable( 0 );
1333 }
1334 else if ( mnCurrentPos )
1335 {
1336 if( mnCurrentPos == mnTop )
1337 {
1338 sal_Int32 nCurVis = GetLastVisibleEntry() - mnTop +1;
1339 SetTopEntry( ( mnTop > nCurVis ) ? ( mnTop-nCurVis+1 ) : 0 );
1340 }
1341
1342 // find first selectable starting from mnTop looking forward
1343 nSelect = maEntryList.FindFirstSelectable( mnTop );
1344 }
1345 bDone = true;
1346 }
1347 maQuickSelectionEngine.Reset();
1348 }
1349 break;
1350
1351 case KEY_PAGEDOWN:
1352 {
1353 if ( IsReadOnly() )
1354 {
1355 SetTopEntry( GetLastVisibleEntry() );
1356 }
1357 else if ( !bCtrl && !bMod2 )
1358 {
1359 if( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
1360 {
1361 nSelect = maEntryList.FindFirstSelectable( 0 );
1362 }
1363 else if ( (mnCurrentPos+1) < maEntryList.GetEntryCount() )
1364 {
1365 sal_Int32 nCount = maEntryList.GetEntryCount();
1366 sal_Int32 nCurVis = GetLastVisibleEntry() - mnTop;
1367 sal_Int32 nTmp = std::min( nCurVis, nCount );
1368 nTmp += mnTop - 1;
1369 if( mnCurrentPos == nTmp && mnCurrentPos != nCount - 1 )
1370 {
1371 tools::Long nTmp2 = std::min( static_cast<tools::Long>(nCount-nCurVis), static_cast<tools::Long>(static_cast<tools::Long>(mnTop)+static_cast<tools::Long>(nCurVis)-1) );
1372 nTmp2 = std::max( tools::Long(0) , nTmp2 );
1373 nTmp = static_cast<sal_Int32>(nTmp2+(nCurVis-1) );
1374 SetTopEntry( static_cast<sal_Int32>(nTmp2) );
1375 }
1376 // find first selectable starting from nTmp looking backwards
1377 nSelect = maEntryList.FindFirstSelectable( nTmp, false );
1378 }
1379 bDone = true;
1380 }
1381 maQuickSelectionEngine.Reset();
1382 }
1383 break;
1384
1385 case KEY_HOME:
1386 {
1387 if ( IsReadOnly() )
1388 {
1389 SetTopEntry( 0 );
1390 }
1391 else if ( !bCtrl && !bMod2 && mnCurrentPos )
1392 {
1393 nSelect = maEntryList.FindFirstSelectable( maEntryList.GetEntryCount() ? 0 : LISTBOX_ENTRY_NOTFOUND );
1394 if( mnTop != 0 )
1395 SetTopEntry( 0 );
1396
1397 bDone = true;
1398 }
1399 maQuickSelectionEngine.Reset();
1400 }
1401 break;
1402
1403 case KEY_END:
1404 {
1405 if ( IsReadOnly() )
1406 {
1407 SetTopEntry( 0xFFFF );
1408 }
1409 else if ( !bCtrl && !bMod2 )
1410 {
1411 if( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND )
1412 {
1413 nSelect = maEntryList.FindFirstSelectable( 0 );
1414 }
1415 else if ( (mnCurrentPos+1) < maEntryList.GetEntryCount() )
1416 {
1417 sal_Int32 nCount = maEntryList.GetEntryCount();
1418 nSelect = maEntryList.FindFirstSelectable( nCount - 1, false );
1419 sal_Int32 nCurVis = GetLastVisibleEntry() - mnTop + 1;
1420 if( nCount > nCurVis )
1421 SetTopEntry( nCount - nCurVis );
1422 }
1423 bDone = true;
1424 }
1425 maQuickSelectionEngine.Reset();
1426 }
1427 break;
1428
1429 case KEY_LEFT:
1430 {
1431 if ( !bCtrl && !bMod2 )
1432 {
1433 ScrollHorz( -HORZ_SCROLL );
1434 bDone = true;
1435 }
1436 maQuickSelectionEngine.Reset();
1437 }
1438 break;
1439
1440 case KEY_RIGHT:
1441 {
1442 if ( !bCtrl && !bMod2 )
1443 {
1444 ScrollHorz( HORZ_SCROLL );
1445 bDone = true;
1446 }
1447 maQuickSelectionEngine.Reset();
1448 }
1449 break;
1450
1451 case KEY_RETURN:
1452 {
1453 if ( !bMod2 && !IsReadOnly() )
1454 {
1455 mnSelectModifier = rKEvt.GetKeyCode().GetModifier();
1456 ImplCallSelect();
1457 bDone = false; // do not catch RETURN
1458 }
1459 maQuickSelectionEngine.Reset();
1460 }
1461 break;
1462
1463 case KEY_SPACE:
1464 {
1465 if ( !bMod2 && !IsReadOnly() )
1466 {
1467 if( mbMulti && ( !mbSimpleMode || ( mbSimpleMode && bCtrl && !bShift ) ) )
1468 {
1469 nSelect = mnCurrentPos;
1470 eLET = LET_KEYSPACE;
1471 }
1472 bDone = true;
1473 }
1474 bHandleKey = true;
1475 }
1476 break;
1477
1478 case KEY_A:
1479 {
1480 if( bCtrl && mbMulti )
1481 {
1482 // paint only once
1483 bool bUpdates = IsUpdateMode();
1484 SetUpdateMode( false );
1485
1486 sal_Int32 nEntryCount = maEntryList.GetEntryCount();
1487 for( sal_Int32 i = 0; i < nEntryCount; i++ )
1488 SelectEntry( i, true );
1489
1490 // tdf#97066 - Update selected items
1491 ImplCallSelect();
1492
1493 // restore update mode
1494 SetUpdateMode( bUpdates );
1495 Invalidate();
1496
1497 maQuickSelectionEngine.Reset();
1498
1499 bDone = true;
1500 }
1501 else
1502 {
1503 bHandleKey = true;
1504 }
1505 }
1506 break;
1507
1508 default:
1509 bHandleKey = true;
1510 break;
1511 }
1512 if (bHandleKey && !IsReadOnly())
1513 {
1514 bDone = maQuickSelectionEngine.HandleKeyEvent( rKEvt );
1515 }
1516
1517 if ( ( nSelect != LISTBOX_ENTRY_NOTFOUND )
1518 && ( ( !maEntryList.IsEntryPosSelected( nSelect ) )
1519 || ( eLET == LET_KEYSPACE )
1520 )
1521 )
1522 {
1523 SAL_WARN_IF( maEntryList.IsEntryPosSelected( nSelect ) && !mbMulti, "vcl", "ImplListBox: Selecting same Entry" );
1524 sal_Int32 nCount = maEntryList.GetEntryCount();
1525 if (nSelect >= nCount)
1526 nSelect = nCount ? nCount-1 : LISTBOX_ENTRY_NOTFOUND;
1527 bool bCurPosChange = (mnCurrentPos != nSelect);
1528 mnCurrentPos = nSelect;
1529 if(SelectEntries( nSelect, eLET, bShift, bCtrl, bCurPosChange))
1530 {
1531 // tdf#129043 Correctly deliver events when changing values with arrow keys in combobox
1532 if (mbIsDropdown && IsReallyVisible())
1533 mbTravelSelect = true;
1534 mnSelectModifier = rKEvt.GetKeyCode().GetModifier();
1535 ImplCallSelect();
1536 mbTravelSelect = false;
1537 }
1538 }
1539
1540 return bDone;
1541 }
1542
1543 namespace
1544 {
1545 vcl::StringEntryIdentifier lcl_getEntry( const ImplEntryList& _rList, sal_Int32 _nPos, OUString& _out_entryText )
1546 {
1547 OSL_PRECOND( ( _nPos != LISTBOX_ENTRY_NOTFOUND ), "lcl_getEntry: invalid position!" );
1548 sal_Int32 nEntryCount( _rList.GetEntryCount() );
1549 if ( _nPos >= nEntryCount )
1550 _nPos = 0;
1551 _out_entryText = _rList.GetEntryText( _nPos );
1552
1553 // vcl::StringEntryIdentifier does not allow for 0 values, but our position is 0-based
1554 // => normalize
1555 return reinterpret_cast< vcl::StringEntryIdentifier >( _nPos + sal_IntPtr(1) );
1556 }
1557
1558 sal_Int32 lcl_getEntryPos( vcl::StringEntryIdentifier _entry )
1559 {
1560 // our pos is 0-based, but StringEntryIdentifier does not allow for a NULL
1561 return static_cast< sal_Int32 >( reinterpret_cast< sal_Int64 >( _entry ) ) - 1;
1562 }
1563 }
1564
1565 vcl::StringEntryIdentifier ImplListBoxWindow::CurrentEntry( OUString& _out_entryText ) const
1566 {
1567 return lcl_getEntry( GetEntryList(), ( mnCurrentPos == LISTBOX_ENTRY_NOTFOUND ) ? 0 : mnCurrentPos, _out_entryText );
1568 }
1569
1570 vcl::StringEntryIdentifier ImplListBoxWindow::NextEntry( vcl::StringEntryIdentifier _currentEntry, OUString& _out_entryText ) const
1571 {
1572 sal_Int32 nNextPos = lcl_getEntryPos( _currentEntry ) + 1;
1573 return lcl_getEntry( GetEntryList(), nNextPos, _out_entryText );
1574 }
1575
1576 void ImplListBoxWindow::SelectEntry( vcl::StringEntryIdentifier _entry )
1577 {
1578 sal_Int32 nSelect = lcl_getEntryPos( _entry );
1579 if ( maEntryList.IsEntryPosSelected( nSelect ) )
1580 {
1581 // ignore that. This method is a callback from the QuickSelectionEngine, which means the user attempted
1582 // to select the given entry by typing its starting letters. No need to act.
1583 return;
1584 }
1585
1586 // normalize
1587 OSL_ENSURE( nSelect < maEntryList.GetEntryCount(), "ImplListBoxWindow::SelectEntry: how that?" );
1588 sal_Int32 nCount = maEntryList.GetEntryCount();
1589 if (nSelect >= nCount)
1590 nSelect = nCount ? nCount-1 : LISTBOX_ENTRY_NOTFOUND;
1591
1592 // make visible
1593 ShowProminentEntry( nSelect );
1594
1595 // actually select
1596 mnCurrentPos = nSelect;
1597 if ( SelectEntries( nSelect, LET_KEYMOVE ) )
1598 {
1599 mbTravelSelect = true;
1600 mnSelectModifier = 0;
1601 ImplCallSelect();
1602 mbTravelSelect = false;
1603 }
1604 }
1605
1606 void ImplListBoxWindow::ImplPaint(vcl::RenderContext& rRenderContext, sal_Int32 nPos)
1607 {
1608 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
1609
1610 const ImplEntryType* pEntry = maEntryList.GetEntryPtr( nPos );
1611 if (!pEntry)
1612 return;
1613
1614 tools::Long nWidth = GetOutputSizePixel().Width();
1615 tools::Long nY = maEntryList.GetAddedHeight(nPos, mnTop);
1616 tools::Rectangle aRect(Point(0, nY), Size(nWidth, pEntry->getHeightWithMargin()));
1617
1618 bool bSelected = maEntryList.IsEntryPosSelected(nPos);
1619 if (bSelected)
1620 {
1621 rRenderContext.SetTextColor(!IsEnabled() ? rStyleSettings.GetDisableColor() : rStyleSettings.GetListBoxWindowHighlightTextColor());
1622 rRenderContext.SetFillColor(rStyleSettings.GetListBoxWindowHighlightColor());
1623 rRenderContext.SetLineColor();
1624 rRenderContext.DrawRect(aRect);
1625 }
1626 else
1627 {
1628 ApplySettings(rRenderContext);
1629 if (!IsEnabled())
1630 rRenderContext.SetTextColor(rStyleSettings.GetDisableColor());
1631 }
1632 rRenderContext.SetTextFillColor();
1633
1634 if (IsUserDrawEnabled())
1635 {
1636 mbInUserDraw = true;
1637 mnUserDrawEntry = nPos;
1638 aRect.AdjustLeft( -mnLeft );
1639 if (nPos < GetEntryList().GetMRUCount())
1640 nPos = GetEntryList().FindEntry(GetEntryList().GetEntryText(nPos));
1641 nPos = nPos - GetEntryList().GetMRUCount();
1642
1643 UserDrawEvent aUDEvt(&rRenderContext, aRect, nPos, bSelected);
1644 maUserDrawHdl.Call( &aUDEvt );
1645 mbInUserDraw = false;
1646 }
1647 else
1648 {
1649 DrawEntry(rRenderContext, nPos, true, true);
1650 }
1651 }
1652
1653 void ImplListBoxWindow::DrawEntry(vcl::RenderContext& rRenderContext, sal_Int32 nPos, bool bDrawImage, bool bDrawText)
1654 {
1655 const ImplEntryType* pEntry = maEntryList.GetEntryPtr(nPos);
1656 if (!pEntry)
1657 return;
1658
1659 tools::Long nEntryHeight = pEntry->getHeightWithMargin();
1660
1661 // when changing this function don't forget to adjust ImplWin::DrawEntry()
1662
1663 if (mbInUserDraw)
1664 nPos = mnUserDrawEntry; // real entry, not the matching entry from MRU
1665
1666 tools::Long nY = maEntryList.GetAddedHeight(nPos, mnTop);
1667
1668 if (bDrawImage && maEntryList.HasImages())
1669 {
1670 Image aImage = maEntryList.GetEntryImage(nPos);
1671 if (!!aImage)
1672 {
1673 Size aImgSz = aImage.GetSizePixel();
1674 Point aPtImg(gnBorder - mnLeft, nY + ((nEntryHeight - aImgSz.Height()) / 2));
1675
1676 if (!IsZoom())
1677 {
1678 rRenderContext.DrawImage(aPtImg, aImage);
1679 }
1680 else
1681 {
1682 aImgSz.setWidth( CalcZoom(aImgSz.Width()) );
1683 aImgSz.setHeight( CalcZoom(aImgSz.Height()) );
1684 rRenderContext.DrawImage(aPtImg, aImgSz, aImage);
1685 }
1686
1687 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
1688 const sal_uInt16 nEdgeBlendingPercent(GetEdgeBlending() ? rStyleSettings.GetEdgeBlending() : 0);
1689
1690 if (nEdgeBlendingPercent && aImgSz.Width() && aImgSz.Height())
1691 {
1692 const Color& rTopLeft(rStyleSettings.GetEdgeBlendingTopLeftColor());
1693 const Color& rBottomRight(rStyleSettings.GetEdgeBlendingBottomRightColor());
1694 const sal_uInt8 nAlpha(255 - ((nEdgeBlendingPercent * 255) / 100));
1695 const BitmapEx aBlendFrame(createAlphaBlendFrame(aImgSz, nAlpha, rTopLeft, rBottomRight));
1696
1697 if (!aBlendFrame.IsEmpty())
1698 {
1699 rRenderContext.DrawBitmapEx(aPtImg, aBlendFrame);
1700 }
1701 }
1702 }
1703 }
1704
1705 if (bDrawText)
1706 {
1707 OUString aStr(maEntryList.GetEntryText(nPos));
1708 if (!aStr.isEmpty())
1709 {
1710 tools::Long nMaxWidth = std::max(mnMaxWidth, GetOutputSizePixel().Width() - 2 * gnBorder);
1711 // a multiline entry should only be as wide as the window
1712 if (pEntry->mnFlags & ListBoxEntryFlags::MultiLine)
1713 nMaxWidth = GetOutputSizePixel().Width() - 2 * gnBorder;
1714
1715 tools::Rectangle aTextRect(Point(gnBorder - mnLeft, nY),
1716 Size(nMaxWidth, nEntryHeight));
1717
1718 if (maEntryList.HasEntryImage(nPos) || IsUserDrawEnabled())
1719 {
1720 tools::Long nImageWidth = std::max(mnMaxImgWidth, maUserItemSize.Width());
1721 aTextRect.AdjustLeft(nImageWidth + IMG_TXT_DISTANCE );
1722 }
1723
1724 DrawTextFlags nDrawStyle = ImplGetTextStyle();
1725 if (pEntry->mnFlags & ListBoxEntryFlags::MultiLine)
1726 nDrawStyle |= MULTILINE_ENTRY_DRAW_FLAGS;
1727 if (pEntry->mnFlags & ListBoxEntryFlags::DrawDisabled)
1728 nDrawStyle |= DrawTextFlags::Disable;
1729
1730 rRenderContext.DrawText(aTextRect, aStr, nDrawStyle);
1731 }
1732 }
1733
1734 if ( !maSeparators.empty() && ( isSeparator(nPos) || isSeparator(nPos-1) ) )
1735 {
1736 Color aOldLineColor(rRenderContext.GetLineColor());
1737 rRenderContext.SetLineColor((GetBackground() != COL_LIGHTGRAY) ? COL_LIGHTGRAY : COL_GRAY);
1738 Point aStartPos(0, nY);
1739 if (isSeparator(nPos))
1740 aStartPos.AdjustY(pEntry->getHeightWithMargin() - 1 );
1741 Point aEndPos(aStartPos);
1742 aEndPos.setX( GetOutputSizePixel().Width() );
1743 rRenderContext.DrawLine(aStartPos, aEndPos);
1744 rRenderContext.SetLineColor(aOldLineColor);
1745 }
1746 }
1747
1748 void ImplListBoxWindow::FillLayoutData() const
1749 {
1750 mxLayoutData.emplace();
1751 const_cast<ImplListBoxWindow*>(this)->Invalidate(tools::Rectangle(Point(0, 0), GetOutDev()->GetOutputSize()));
1752 }
1753
1754 void ImplListBoxWindow::ImplDoPaint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
1755 {
1756 sal_Int32 nCount = maEntryList.GetEntryCount();
1757
1758 bool bShowFocusRect = mbHasFocusRect;
1759 if (mbHasFocusRect)
1760 ImplHideFocusRect();
1761
1762 tools::Long nY = 0; // + gnBorder;
1763 tools::Long nHeight = GetOutputSizePixel().Height();// - mnMaxHeight + gnBorder;
1764
1765 for (sal_Int32 i = mnTop; i < nCount && nY < nHeight + mnMaxHeight; i++)
1766 {
1767 const ImplEntryType* pEntry = maEntryList.GetEntryPtr(i);
1768 tools::Long nEntryHeight = pEntry->getHeightWithMargin();
1769 if (nY + nEntryHeight >= rRect.Top() &&
1770 nY <= rRect.Bottom() + mnMaxHeight)
1771 {
1772 ImplPaint(rRenderContext, i);
1773 }
1774 nY += nEntryHeight;
1775 }
1776
1777 tools::Long nHeightDiff = maEntryList.GetAddedHeight(mnCurrentPos, mnTop);
1778 maFocusRect.SetPos(Point(0, nHeightDiff));
1779 Size aSz(maFocusRect.GetWidth(), maEntryList.GetEntryHeight(mnCurrentPos));
1780 maFocusRect.SetSize(aSz);
1781 if (HasFocus() && bShowFocusRect)
1782 ImplShowFocusRect();
1783 }
1784
1785 void ImplListBoxWindow::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
1786 {
1787 if (SupportsDoubleBuffering())
1788 {
1789 // This widget is explicitly double-buffered, so avoid partial paints.
1790 tools::Rectangle aRect(Point(0, 0), GetOutputSizePixel());
1791 ImplDoPaint(rRenderContext, aRect);
1792 }
1793 else
1794 ImplDoPaint(rRenderContext, rRect);
1795 }
1796
1797 sal_uInt16 ImplListBoxWindow::GetDisplayLineCount() const
1798 {
1799 // FIXME: ListBoxEntryFlags::MultiLine
1800
1801 const sal_Int32 nCount = maEntryList.GetEntryCount()-mnTop;
1802 tools::Long nHeight = GetOutputSizePixel().Height();// - mnMaxHeight + gnBorder;
1803 sal_uInt16 nEntries = static_cast< sal_uInt16 >( ( nHeight + mnMaxHeight - 1 ) / mnMaxHeight );
1804 if( nEntries > nCount )
1805 nEntries = static_cast<sal_uInt16>(nCount);
1806
1807 return nEntries;
1808 }
1809
1810 void ImplListBoxWindow::Resize()
1811 {
1812 Control::Resize();
1813
1814 bool bShowFocusRect = mbHasFocusRect;
1815 if ( bShowFocusRect )
1816 ImplHideFocusRect();
1817
1818 if( mnCurrentPos != LISTBOX_ENTRY_NOTFOUND )
1819 {
1820 Size aSz( GetOutputSizePixel().Width(), maEntryList.GetEntryHeight( mnCurrentPos ) );
1821 maFocusRect.SetSize( aSz );
1822 }
1823
1824 if ( bShowFocusRect )
1825 ImplShowFocusRect();
1826
1827 ImplClearLayoutData();
1828 }
1829
1830 void ImplListBoxWindow::GetFocus()
1831 {
1832 sal_Int32 nPos = mnCurrentPos;
1833 if ( nPos == LISTBOX_ENTRY_NOTFOUND )
1834 nPos = 0;
1835 tools::Long nHeightDiff = maEntryList.GetAddedHeight( nPos, mnTop );
1836 maFocusRect.SetPos( Point( 0, nHeightDiff ) );
1837 Size aSz( maFocusRect.GetWidth(), maEntryList.GetEntryHeight( nPos ) );
1838 maFocusRect.SetSize( aSz );
1839 ImplShowFocusRect();
1840 Control::GetFocus();
1841 }
1842
1843 void ImplListBoxWindow::LoseFocus()
1844 {
1845 ImplHideFocusRect();
1846 Control::LoseFocus();
1847 }
1848
1849 void ImplListBoxWindow::SetTopEntry( sal_Int32 nTop )
1850 {
1851 if( maEntryList.GetEntryCount() == 0 )
1852 return;
1853
1854 tools::Long nWHeight = PixelToLogic( GetSizePixel() ).Height();
1855
1856 sal_Int32 nLastEntry = maEntryList.GetEntryCount()-1;
1857 if( nTop > nLastEntry )
1858 nTop = nLastEntry;
1859 const ImplEntryType* pLast = maEntryList.GetEntryPtr( nLastEntry );
1860 while( nTop > 0 && maEntryList.GetAddedHeight( nLastEntry, nTop-1 ) + pLast->getHeightWithMargin() <= nWHeight )
1861 nTop--;
1862
1863 if ( nTop == mnTop )
1864 return;
1865
1866 ImplClearLayoutData();
1867 tools::Long nDiff = maEntryList.GetAddedHeight( mnTop, nTop );
1868 PaintImmediately();
1869 ImplHideFocusRect();
1870 mnTop = nTop;
1871 Scroll( 0, nDiff );
1872 PaintImmediately();
1873 if( HasFocus() )
1874 ImplShowFocusRect();
1875 maScrollHdl.Call( this );
1876 }
1877
1878 void ImplListBoxWindow::ShowProminentEntry( sal_Int32 nEntryPos )
1879 {
1880 sal_Int32 nPos = nEntryPos;
1881 auto nWHeight = PixelToLogic( GetSizePixel() ).Height();
1882 while( nEntryPos > 0 && maEntryList.GetAddedHeight( nPos+1, nEntryPos ) < nWHeight/2 )
1883 nEntryPos--;
1884
1885 SetTopEntry( nEntryPos );
1886 }
1887
1888 void ImplListBoxWindow::SetLeftIndent( tools::Long n )
1889 {
1890 ScrollHorz( n - mnLeft );
1891 }
1892
1893 void ImplListBoxWindow::ScrollHorz( tools::Long n )
1894 {
1895 tools::Long nDiff = 0;
1896 if ( n > 0 )
1897 {
1898 tools::Long nWidth = GetOutputSizePixel().Width();
1899 if( ( mnMaxWidth - mnLeft + n ) > nWidth )
1900 nDiff = n;
1901 }
1902 else if ( n < 0 )
1903 {
1904 if( mnLeft )
1905 {
1906 tools::Long nAbs = -n;
1907 nDiff = - std::min( mnLeft, nAbs );
1908 }
1909 }
1910
1911 if ( nDiff )
1912 {
1913 ImplClearLayoutData();
1914 mnLeft = sal::static_int_cast<sal_uInt16>(mnLeft + nDiff);
1915 PaintImmediately();
1916 ImplHideFocusRect();
1917 Scroll( -nDiff, 0 );
1918 PaintImmediately();
1919 if( HasFocus() )
1920 ImplShowFocusRect();
1921 maScrollHdl.Call( this );
1922 }
1923 }
1924
1925 void ImplListBoxWindow::SetSeparatorPos( sal_Int32 n )
1926 {
1927 maSeparators.clear();
1928
1929 if ( n != LISTBOX_ENTRY_NOTFOUND )
1930 {
1931 maSeparators.insert( n );
1932 }
1933 }
1934
1935 sal_Int32 ImplListBoxWindow::GetSeparatorPos() const
1936 {
1937 if (!maSeparators.empty())
1938 return *(maSeparators.begin());
1939 else
1940 return LISTBOX_ENTRY_NOTFOUND;
1941 }
1942
1943 bool ImplListBoxWindow::isSeparator( const sal_Int32 &n) const
1944 {
1945 return maSeparators.find(n) != maSeparators.end();
1946 }
1947
1948 Size ImplListBoxWindow::CalcSize(sal_Int32 nMaxLines) const
1949 {
1950 // FIXME: ListBoxEntryFlags::MultiLine
1951
1952 Size aSz;
1953 aSz.setHeight(nMaxLines * GetEntryHeightWithMargin());
1954 aSz.setWidth( mnMaxWidth + 2*gnBorder );
1955 return aSz;
1956 }
1957
1958 tools::Rectangle ImplListBoxWindow::GetBoundingRectangle( sal_Int32 nItem ) const
1959 {
1960 const ImplEntryType* pEntry = maEntryList.GetEntryPtr( nItem );
1961 Size aSz( GetSizePixel().Width(), pEntry ? pEntry->getHeightWithMargin() : GetEntryHeightWithMargin() );
1962 tools::Long nY = maEntryList.GetAddedHeight( nItem, GetTopEntry() ) + GetEntryList().GetMRUCount()*GetEntryHeightWithMargin();
1963 tools::Rectangle aRect( Point( 0, nY ), aSz );
1964 return aRect;
1965 }
1966
1967 void ImplListBoxWindow::StateChanged( StateChangedType nType )
1968 {
1969 Control::StateChanged( nType );
1970
1971 if ( nType == StateChangedType::Zoom )
1972 {
1973 ApplySettings(*GetOutDev());
1974 ImplCalcMetrics();
1975 Invalidate();
1976 }
1977 else if ( nType == StateChangedType::UpdateMode )
1978 {
1979 if ( IsUpdateMode() && IsReallyVisible() )
1980 Invalidate();
1981 }
1982 else if ( nType == StateChangedType::ControlFont )
1983 {
1984 ApplySettings(*GetOutDev());
1985 ImplCalcMetrics();
1986 Invalidate();
1987 }
1988 else if ( nType == StateChangedType::ControlForeground )
1989 {
1990 ApplySettings(*GetOutDev());
1991 Invalidate();
1992 }
1993 else if ( nType == StateChangedType::ControlBackground )
1994 {
1995 ApplySettings(*GetOutDev());
1996 Invalidate();
1997 }
1998 else if( nType == StateChangedType::Enable )
1999 {
2000 Invalidate();
2001 }
2002
2003 ImplClearLayoutData();
2004 }
2005
2006 void ImplListBoxWindow::DataChanged( const DataChangedEvent& rDCEvt )
2007 {
2008 Control::DataChanged( rDCEvt );
2009
2010 if ( (rDCEvt.GetType() == DataChangedEventType::FONTS) ||
2011 (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION) ||
2012 ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
2013 (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) )
2014 {
2015 ImplClearLayoutData();
2016 ApplySettings(*GetOutDev());
2017 ImplCalcMetrics();
2018 Invalidate();
2019 }
2020 }
2021
2022 DrawTextFlags ImplListBoxWindow::ImplGetTextStyle() const
2023 {
2024 DrawTextFlags nTextStyle = DrawTextFlags::VCenter;
2025
2026 if (maEntryList.HasImages())
2027 nTextStyle |= DrawTextFlags::Left;
2028 else if (mbCenter)
2029 nTextStyle |= DrawTextFlags::Center;
2030 else if (mbRight)
2031 nTextStyle |= DrawTextFlags::Right;
2032 else
2033 nTextStyle |= DrawTextFlags::Left;
2034
2035 return nTextStyle;
2036 }
2037
2038 ImplListBox::ImplListBox( vcl::Window* pParent, WinBits nWinStyle ) :
2039 Control( pParent, nWinStyle ),
2040 maLBWindow(VclPtr<ImplListBoxWindow>::Create( this, nWinStyle&(~WB_BORDER) ))
2041 {
2042 // for native widget rendering we must be able to detect this window type
2043 SetType( WindowType::LISTBOXWINDOW );
2044
2045 mpVScrollBar = VclPtr<ScrollBar>::Create( this, WB_VSCROLL | WB_DRAG );
2046 mpHScrollBar = VclPtr<ScrollBar>::Create( this, WB_HSCROLL | WB_DRAG );
2047 mpScrollBarBox = VclPtr<ScrollBarBox>::Create( this );
2048
2049 Link<ScrollBar*,void> aLink( LINK( this, ImplListBox, ScrollBarHdl ) );
2050 mpVScrollBar->SetScrollHdl( aLink );
2051 mpHScrollBar->SetScrollHdl( aLink );
2052
2053 mbVScroll = false;
2054 mbHScroll = false;
2055 mbAutoHScroll = ( nWinStyle & WB_AUTOHSCROLL );
2056 mbEdgeBlending = false;
2057
2058 maLBWindow->SetScrollHdl( LINK( this, ImplListBox, LBWindowScrolled ) );
2059 maLBWindow->SetMRUChangedHdl( LINK( this, ImplListBox, MRUChanged ) );
2060 maLBWindow->SetEdgeBlending(GetEdgeBlending());
2061 maLBWindow->Show();
2062 }
2063
2064 ImplListBox::~ImplListBox()
2065 {
2066 disposeOnce();
2067 }
2068
2069 void ImplListBox::dispose()
2070 {
2071 mpHScrollBar.disposeAndClear();
2072 mpVScrollBar.disposeAndClear();
2073 mpScrollBarBox.disposeAndClear();
2074 maLBWindow.disposeAndClear();
2075 Control::dispose();
2076 }
2077
2078 void ImplListBox::Clear()
2079 {
2080 maLBWindow->Clear();
2081 if ( GetEntryList().GetMRUCount() )
2082 {
2083 maLBWindow->GetEntryList().SetMRUCount( 0 );
2084 maLBWindow->SetSeparatorPos( LISTBOX_ENTRY_NOTFOUND );
2085 }
2086 mpVScrollBar->SetThumbPos( 0 );
2087 mpHScrollBar->SetThumbPos( 0 );
2088 CompatStateChanged( StateChangedType::Data );
2089 }
2090
2091 sal_Int32 ImplListBox::InsertEntry( sal_Int32 nPos, const OUString& rStr )
2092 {
2093 ImplEntryType* pNewEntry = new ImplEntryType( rStr );
2094 sal_Int32 nNewPos = maLBWindow->InsertEntry( nPos, pNewEntry );
2095 CompatStateChanged( StateChangedType::Data );
2096 return nNewPos;
2097 }
2098
2099 sal_Int32 ImplListBox::InsertEntry( sal_Int32 nPos, const OUString& rStr, const Image& rImage )
2100 {
2101 ImplEntryType* pNewEntry = new ImplEntryType( rStr, rImage );
2102 sal_Int32 nNewPos = maLBWindow->InsertEntry( nPos, pNewEntry );
2103 CompatStateChanged( StateChangedType::Data );
2104 return nNewPos;
2105 }
2106
2107 void ImplListBox::RemoveEntry( sal_Int32 nPos )
2108 {
2109 maLBWindow->RemoveEntry( nPos );
2110 CompatStateChanged( StateChangedType::Data );
2111 }
2112
2113 void ImplListBox::SetEntryFlags( sal_Int32 nPos, ListBoxEntryFlags nFlags )
2114 {
2115 maLBWindow->SetEntryFlags( nPos, nFlags );
2116 }
2117
2118 void ImplListBox::SelectEntry( sal_Int32 nPos, bool bSelect )
2119 {
2120 maLBWindow->SelectEntry( nPos, bSelect );
2121 }
2122
2123 void ImplListBox::SetNoSelection()
2124 {
2125 maLBWindow->DeselectAll();
2126 }
2127
2128 void ImplListBox::GetFocus()
2129 {
2130 if (maLBWindow)
2131 maLBWindow->GrabFocus();
2132 else
2133 Control::GetFocus();
2134 }
2135
2136 void ImplListBox::Resize()
2137 {
2138 Control::Resize();
2139 ImplResizeControls();
2140 ImplCheckScrollBars();
2141 }
2142
2143 IMPL_LINK_NOARG(ImplListBox, MRUChanged, LinkParamNone*, void)
2144 {
2145 CompatStateChanged( StateChangedType::Data );
2146 }
2147
2148 IMPL_LINK_NOARG(ImplListBox, LBWindowScrolled, ImplListBoxWindow*, void)
2149 {
2150 tools::Long nSet = GetTopEntry();
2151 if( nSet > mpVScrollBar->GetRangeMax() )
2152 mpVScrollBar->SetRangeMax( GetEntryList().GetEntryCount() );
2153 mpVScrollBar->SetThumbPos( GetTopEntry() );
2154
2155 mpHScrollBar->SetThumbPos( GetLeftIndent() );
2156
2157 maScrollHdl.Call( this );
2158 }
2159
2160 IMPL_LINK( ImplListBox, ScrollBarHdl, ScrollBar*, pSB, void )
2161 {
2162 sal_uInt16 nPos = static_cast<sal_uInt16>(pSB->GetThumbPos());
2163 if( pSB == mpVScrollBar )
2164 SetTopEntry( nPos );
2165 else if( pSB == mpHScrollBar )
2166 SetLeftIndent( nPos );
2167 if( GetParent() )
2168 GetParent()->Invalidate( InvalidateFlags::Update );
2169 }
2170
2171 void ImplListBox::ImplCheckScrollBars()
2172 {
2173 bool bArrange = false;
2174
2175 Size aOutSz = GetOutputSizePixel();
2176 sal_Int32 nEntries = GetEntryList().GetEntryCount();
2177 sal_uInt16 nMaxVisEntries = static_cast<sal_uInt16>(aOutSz.Height() / GetEntryHeightWithMargin());
2178
2179 // vertical ScrollBar
2180 if( nEntries > nMaxVisEntries )
2181 {
2182 if( !mbVScroll )
2183 bArrange = true;
2184 mbVScroll = true;
2185
2186 // check of the scrolled-out region
2187 if( GetEntryList().GetSelectedEntryCount() == 1 &&
2188 GetEntryList().GetSelectedEntryPos( 0 ) != LISTBOX_ENTRY_NOTFOUND )
2189 ShowProminentEntry( GetEntryList().GetSelectedEntryPos( 0 ) );
2190 else
2191 SetTopEntry( GetTopEntry() ); // MaxTop is being checked...
2192 }
2193 else
2194 {
2195 if( mbVScroll )
2196 bArrange = true;
2197 mbVScroll = false;
2198 SetTopEntry( 0 );
2199 }
2200
2201 // horizontal ScrollBar
2202 if( mbAutoHScroll )
2203 {
2204 tools::Long nWidth = static_cast<sal_uInt16>(aOutSz.Width());
2205 if ( mbVScroll )
2206 nWidth -= mpVScrollBar->GetSizePixel().Width();
2207
2208 tools::Long nMaxWidth = GetMaxEntryWidth();
2209 if( nWidth < nMaxWidth )
2210 {
2211 if( !mbHScroll )
2212 bArrange = true;
2213 mbHScroll = true;
2214
2215 if ( !mbVScroll ) // maybe we do need one now
2216 {
2217 nMaxVisEntries = static_cast<sal_uInt16>( ( aOutSz.Height() - mpHScrollBar->GetSizePixel().Height() ) / GetEntryHeightWithMargin() );
2218 if( nEntries > nMaxVisEntries )
2219 {
2220 bArrange = true;
2221 mbVScroll = true;
2222
2223 // check of the scrolled-out region
2224 if( GetEntryList().GetSelectedEntryCount() == 1 &&
2225 GetEntryList().GetSelectedEntryPos( 0 ) != LISTBOX_ENTRY_NOTFOUND )
2226 ShowProminentEntry( GetEntryList().GetSelectedEntryPos( 0 ) );
2227 else
2228 SetTopEntry( GetTopEntry() ); // MaxTop is being checked...
2229 }
2230 }
2231
2232 // check of the scrolled-out region
2233 sal_uInt16 nMaxLI = static_cast<sal_uInt16>(nMaxWidth - nWidth);
2234 if ( nMaxLI < GetLeftIndent() )
2235 SetLeftIndent( nMaxLI );
2236 }
2237 else
2238 {
2239 if( mbHScroll )
2240 bArrange = true;
2241 mbHScroll = false;
2242 SetLeftIndent( 0 );
2243 }
2244 }
2245
2246 if( bArrange )
2247 ImplResizeControls();
2248
2249 ImplInitScrollBars();
2250 }
2251
2252 void ImplListBox::ImplInitScrollBars()
2253 {
2254 Size aOutSz = maLBWindow->GetOutputSizePixel();
2255
2256 if ( mbVScroll )
2257 {
2258 sal_Int32 nEntries = GetEntryList().GetEntryCount();
2259 sal_uInt16 nVisEntries = static_cast<sal_uInt16>(aOutSz.Height() / GetEntryHeightWithMargin());
2260 mpVScrollBar->SetRangeMax( nEntries );
2261 mpVScrollBar->SetVisibleSize( nVisEntries );
2262 mpVScrollBar->SetPageSize( nVisEntries - 1 );
2263 }
2264
2265 if ( mbHScroll )
2266 {
2267 mpHScrollBar->SetRangeMax( GetMaxEntryWidth() + HORZ_SCROLL );
2268 mpHScrollBar->SetVisibleSize( static_cast<sal_uInt16>(aOutSz.Width()) );
2269 mpHScrollBar->SetLineSize( HORZ_SCROLL );
2270 mpHScrollBar->SetPageSize( aOutSz.Width() - HORZ_SCROLL );
2271 }
2272 }
2273
2274 void ImplListBox::ImplResizeControls()
2275 {
2276 // Here we only position the Controls; if the Scrollbars are to be
2277 // visible is already determined in ImplCheckScrollBars
2278
2279 Size aOutSz = GetOutputSizePixel();
2280 tools::Long nSBWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
2281 nSBWidth = CalcZoom( nSBWidth );
2282
2283 Size aInnerSz( aOutSz );
2284 if ( mbVScroll )
2285 aInnerSz.AdjustWidth( -nSBWidth );
2286 if ( mbHScroll )
2287 aInnerSz.AdjustHeight( -nSBWidth );
2288
2289 Point aWinPos( 0, 0 );
2290 maLBWindow->SetPosSizePixel( aWinPos, aInnerSz );
2291
2292 // ScrollBarBox
2293 if( mbVScroll && mbHScroll )
2294 {
2295 Point aBoxPos( aInnerSz.Width(), aInnerSz.Height() );
2296 mpScrollBarBox->SetPosSizePixel( aBoxPos, Size( nSBWidth, nSBWidth ) );
2297 mpScrollBarBox->Show();
2298 }
2299 else
2300 {
2301 mpScrollBarBox->Hide();
2302 }
2303
2304 // vertical ScrollBar
2305 if( mbVScroll )
2306 {
2307 // Scrollbar on left or right side?
2308 Point aVPos( aOutSz.Width() - nSBWidth, 0 );
2309 mpVScrollBar->SetPosSizePixel( aVPos, Size( nSBWidth, aInnerSz.Height() ) );
2310 mpVScrollBar->Show();
2311 }
2312 else
2313 {
2314 mpVScrollBar->Hide();
2315 // #107254# Don't reset top entry after resize, but check for max top entry
2316 SetTopEntry( GetTopEntry() );
2317 }
2318
2319 // horizontal ScrollBar
2320 if( mbHScroll )
2321 {
2322 Point aHPos( 0, aOutSz.Height() - nSBWidth );
2323 mpHScrollBar->SetPosSizePixel( aHPos, Size( aInnerSz.Width(), nSBWidth ) );
2324 mpHScrollBar->Show();
2325 }
2326 else
2327 {
2328 mpHScrollBar->Hide();
2329 SetLeftIndent( 0 );
2330 }
2331 }
2332
2333 void ImplListBox::StateChanged( StateChangedType nType )
2334 {
2335 if ( nType == StateChangedType::InitShow )
2336 {
2337 ImplCheckScrollBars();
2338 }
2339 else if ( ( nType == StateChangedType::UpdateMode ) || ( nType == StateChangedType::Data ) )
2340 {
2341 bool bUpdate = IsUpdateMode();
2342 maLBWindow->SetUpdateMode( bUpdate );
2343 if ( bUpdate && IsReallyVisible() )
2344 ImplCheckScrollBars();
2345 }
2346 else if( nType == StateChangedType::Enable )
2347 {
2348 mpHScrollBar->Enable( IsEnabled() );
2349 mpVScrollBar->Enable( IsEnabled() );
2350 mpScrollBarBox->Enable( IsEnabled() );
2351 maLBWindow->Enable( IsEnabled() );
2352
2353 Invalidate();
2354 }
2355 else if ( nType == StateChangedType::Zoom )
2356 {
2357 maLBWindow->SetZoom( GetZoom() );
2358 Resize();
2359 }
2360 else if ( nType == StateChangedType::ControlFont )
2361 {
2362 maLBWindow->SetControlFont( GetControlFont() );
2363 }
2364 else if ( nType == StateChangedType::ControlForeground )
2365 {
2366 maLBWindow->SetControlForeground( GetControlForeground() );
2367 }
2368 else if ( nType == StateChangedType::ControlBackground )
2369 {
2370 maLBWindow->SetControlBackground( GetControlBackground() );
2371 }
2372 else if( nType == StateChangedType::Mirroring )
2373 {
2374 maLBWindow->EnableRTL( IsRTLEnabled() );
2375 mpHScrollBar->EnableRTL( IsRTLEnabled() );
2376 mpVScrollBar->EnableRTL( IsRTLEnabled() );
2377 ImplResizeControls();
2378 }
2379
2380 Control::StateChanged( nType );
2381 }
2382
2383 bool ImplListBox::EventNotify( NotifyEvent& rNEvt )
2384 {
2385 bool bDone = false;
2386 if ( rNEvt.GetType() == NotifyEventType::COMMAND )
2387 {
2388 const CommandEvent& rCEvt = *rNEvt.GetCommandEvent();
2389 if ( rCEvt.GetCommand() == CommandEventId::Wheel )
2390 {
2391 const CommandWheelData* pData = rCEvt.GetWheelData();
2392 if( !pData->GetModifier() && ( pData->GetMode() == CommandWheelMode::SCROLL ) )
2393 {
2394 bDone = HandleScrollCommand( rCEvt, mpHScrollBar, mpVScrollBar );
2395 }
2396 }
2397 else if (rCEvt.GetCommand() == CommandEventId::GesturePan)
2398 {
2399 bDone = HandleScrollCommand(rCEvt, mpHScrollBar, mpVScrollBar);
2400 }
2401 }
2402
2403 return bDone || Window::EventNotify( rNEvt );
2404 }
2405
2406 const Wallpaper& ImplListBox::GetDisplayBackground() const
2407 {
2408 return maLBWindow->GetDisplayBackground();
2409 }
2410
2411 bool ImplListBox::HandleWheelAsCursorTravel(const CommandEvent& rCEvt, Control& rControl)
2412 {
2413 bool bDone = false;
2414 if ( rCEvt.GetCommand() == CommandEventId::Wheel )
2415 {
2416 const CommandWheelData* pData = rCEvt.GetWheelData();
2417 if( !pData->GetModifier() && ( pData->GetMode() == CommandWheelMode::SCROLL ) )
2418 {
2419 if (!rControl.HasChildPathFocus())
2420 rControl.GrabFocus();
2421 sal_uInt16 nKey = ( pData->GetDelta() < 0 ) ? KEY_DOWN : KEY_UP;
2422 KeyEvent aKeyEvent( 0, vcl::KeyCode( nKey ) );
2423 bDone = ProcessKeyInput( aKeyEvent );
2424 }
2425 }
2426 return bDone;
2427 }
2428
2429 void ImplListBox::SetMRUEntries( std::u16string_view rEntries, sal_Unicode cSep )
2430 {
2431 bool bChanges = GetEntryList().GetMRUCount() != 0;
2432
2433 // Remove old MRU entries
2434 for ( sal_Int32 n = GetEntryList().GetMRUCount();n; )
2435 maLBWindow->RemoveEntry( --n );
2436
2437 sal_Int32 nMRUCount = 0;
2438 sal_Int32 nIndex = 0;
2439 do
2440 {
2441 OUString aEntry( o3tl::getToken(rEntries, 0, cSep, nIndex ) );
2442 // Accept only existing entries
2443 if ( GetEntryList().FindEntry( aEntry ) != LISTBOX_ENTRY_NOTFOUND )
2444 {
2445 ImplEntryType* pNewEntry = new ImplEntryType( aEntry );
2446 maLBWindow->InsertEntry(nMRUCount++, pNewEntry, false);
2447 bChanges = true;
2448 }
2449 }
2450 while ( nIndex >= 0 );
2451
2452 if ( bChanges )
2453 {
2454 maLBWindow->GetEntryList().SetMRUCount( nMRUCount );
2455 SetSeparatorPos( nMRUCount ? nMRUCount-1 : 0 );
2456 CompatStateChanged( StateChangedType::Data );
2457 }
2458 }
2459
2460 OUString ImplListBox::GetMRUEntries( sal_Unicode cSep ) const
2461 {
2462 OUStringBuffer aEntries;
2463 for ( sal_Int32 n = 0; n < GetEntryList().GetMRUCount(); n++ )
2464 {
2465 aEntries.append(GetEntryList().GetEntryText( n ));
2466 if( n < ( GetEntryList().GetMRUCount() - 1 ) )
2467 aEntries.append(cSep);
2468 }
2469 return aEntries.makeStringAndClear();
2470 }
2471
2472 void ImplListBox::SetEdgeBlending(bool bNew)
2473 {
2474 if(mbEdgeBlending != bNew)
2475 {
2476 mbEdgeBlending = bNew;
2477 maLBWindow->SetEdgeBlending(GetEdgeBlending());
2478 }
2479 }
2480
2481 void ImplListBox::SetHighlightColor(const Color& rColor)
2482 {
2483 AllSettings aSettings(GetSettings());
2484 StyleSettings aStyle(aSettings.GetStyleSettings());
2485 aStyle.SetHighlightColor(rColor);
2486 aSettings.SetStyleSettings(aStyle);
2487 SetSettings(aSettings);
2488
2489 AllSettings aSettingsLB(maLBWindow->GetSettings());
2490 StyleSettings aStyleLB(aSettingsLB.GetStyleSettings());
2491 aStyleLB.SetListBoxWindowHighlightColor(rColor);
2492 aSettingsLB.SetStyleSettings(aStyleLB);
2493 maLBWindow->SetSettings(aSettingsLB);
2494 }
2495
2496 void ImplListBox::SetHighlightTextColor(const Color& rColor)
2497 {
2498 AllSettings aSettings(GetSettings());
2499 StyleSettings aStyle(aSettings.GetStyleSettings());
2500 aStyle.SetHighlightTextColor(rColor);
2501 aSettings.SetStyleSettings(aStyle);
2502 SetSettings(aSettings);
2503
2504 AllSettings aSettingsLB(maLBWindow->GetSettings());
2505 StyleSettings aStyleLB(aSettingsLB.GetStyleSettings());
2506 aStyleLB.SetListBoxWindowHighlightTextColor(rColor);
2507 aSettingsLB.SetStyleSettings(aStyleLB);
2508 maLBWindow->SetSettings(aSettingsLB);
2509 }
2510
2511 ImplWin::ImplWin( vcl::Window* pParent, WinBits nWinStyle ) :
2512 Control ( pParent, nWinStyle )
2513 {
2514 if ( IsNativeControlSupported(ControlType::Listbox, ControlPart::Entire)
2515 && ! IsNativeControlSupported(ControlType::Listbox, ControlPart::ButtonDown) )
2516 SetBackground();
2517 else
2518 SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetFieldColor() ) );
2519
2520 ImplGetWindowImpl()->mbUseNativeFocus = ImplGetSVData()->maNWFData.mbNoFocusRects;
2521
2522 mbEdgeBlending = false;
2523 mnItemPos = LISTBOX_ENTRY_NOTFOUND;
2524 }
2525
2526 void ImplWin::MouseButtonDown( const MouseEvent& )
2527 {
2528 if( IsEnabled() )
2529 {
2530 maMBDownHdl.Call(this);
2531 }
2532 }
2533
2534 void ImplWin::FillLayoutData() const
2535 {
2536 mxLayoutData.emplace();
2537 ImplWin* pThis = const_cast<ImplWin*>(this);
2538 pThis->ImplDraw(*pThis->GetOutDev(), true);
2539 }
2540
2541 void ImplWin::ImplDraw(vcl::RenderContext& rRenderContext, bool bLayout)
2542 {
2543 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
2544
2545 if (!bLayout)
2546 {
2547 bool bNativeOK = false;
2548 bool bHasFocus = HasFocus();
2549 bool bIsEnabled = IsEnabled();
2550
2551 ControlState nState = ControlState::ENABLED;
2552 if (rRenderContext.IsNativeControlSupported(ControlType::Listbox, ControlPart::Entire)
2553 && rRenderContext.IsNativeControlSupported(ControlType::Listbox, ControlPart::HasBackgroundTexture) )
2554 {
2555 // Repaint the (focused) area similarly to
2556 // ImplSmallBorderWindowView::DrawWindow() in
2557 // vcl/source/window/brdwin.cxx
2558 vcl::Window *pWin = GetParent();
2559
2560 ImplControlValue aControlValue;
2561 bIsEnabled &= pWin->IsEnabled();
2562 if ( !bIsEnabled )
2563 nState &= ~ControlState::ENABLED;
2564 bHasFocus |= pWin->HasFocus();
2565 if ( bHasFocus )
2566 nState |= ControlState::FOCUSED;
2567
2568 // The listbox is painted over the entire control including the
2569 // border, but ImplWin does not contain the border => correction
2570 // needed.
2571 sal_Int32 nLeft, nTop, nRight, nBottom;
2572 pWin->GetBorder( nLeft, nTop, nRight, nBottom );
2573 Point aPoint( -nLeft, -nTop );
2574 tools::Rectangle aCtrlRegion( aPoint - GetPosPixel(), pWin->GetSizePixel() );
2575
2576 bool bMouseOver = pWin->IsMouseOver();
2577 if (!bMouseOver)
2578 {
2579 vcl::Window *pChild = pWin->GetWindow( GetWindowType::FirstChild );
2580 while( pChild )
2581 {
2582 bMouseOver = pChild->IsMouseOver();
2583 if (bMouseOver)
2584 break;
2585 pChild = pChild->GetWindow( GetWindowType::Next );
2586 }
2587 }
2588 if( bMouseOver )
2589 nState |= ControlState::ROLLOVER;
2590
2591 Color aBackgroundColor = COL_AUTO;
2592 if (IsControlBackground())
2593 aBackgroundColor = GetControlBackground();
2594
2595 // if parent has no border, then nobody has drawn the background
2596 // since no border window exists. so draw it here.
2597 WinBits nParentStyle = pWin->GetStyle();
2598 if( ! (nParentStyle & WB_BORDER) || (nParentStyle & WB_NOBORDER) )
2599 {
2600 tools::Rectangle aParentRect( Point( 0, 0 ), pWin->GetSizePixel() );
2601 pWin->GetOutDev()->DrawNativeControl( ControlType::Listbox, ControlPart::Entire, aParentRect,
2602 nState, aControlValue, OUString(), aBackgroundColor);
2603 }
2604
2605 bNativeOK = rRenderContext.DrawNativeControl(ControlType::Listbox, ControlPart::Entire, aCtrlRegion,
2606 nState, aControlValue, OUString(), aBackgroundColor);
2607 }
2608
2609 if (bIsEnabled)
2610 {
2611 if (bHasFocus && !ImplGetSVData()->maNWFData.mbDDListBoxNoTextArea)
2612 {
2613 if ( !ImplGetSVData()->maNWFData.mbNoFocusRects )
2614 {
2615 rRenderContext.SetFillColor( rStyleSettings.GetHighlightColor() );
2616 rRenderContext.SetTextColor( rStyleSettings.GetHighlightTextColor() );
2617 }
2618 else
2619 {
2620 rRenderContext.SetLineColor();
2621 rRenderContext.SetFillColor();
2622 rRenderContext.SetTextColor( rStyleSettings.GetFieldTextColor() );
2623 }
2624 rRenderContext.DrawRect( maFocusRect );
2625 }
2626 else
2627 {
2628 Color aColor;
2629 if (IsControlForeground())
2630 aColor = GetControlForeground();
2631 else if (ImplGetSVData()->maNWFData.mbDDListBoxNoTextArea)
2632 {
2633 if( bNativeOK && (nState & ControlState::ROLLOVER) )
2634 aColor = rStyleSettings.GetButtonRolloverTextColor();
2635 else
2636 aColor = rStyleSettings.GetButtonTextColor();
2637 }
2638 else
2639 {
2640 if( bNativeOK && (nState & ControlState::ROLLOVER) )
2641 aColor = rStyleSettings.GetFieldRolloverTextColor();
2642 else
2643 aColor = rStyleSettings.GetFieldTextColor();
2644 }
2645 rRenderContext.SetTextColor(aColor);
2646 if (!bNativeOK)
2647 rRenderContext.Erase(maFocusRect);
2648 }
2649 }
2650 else // Disabled
2651 {
2652 rRenderContext.SetTextColor(rStyleSettings.GetDisableColor());
2653 if (!bNativeOK)
2654 rRenderContext.Erase(maFocusRect);
2655 }
2656 }
2657
2658 DrawEntry(rRenderContext, bLayout);
2659 }
2660
2661 void ImplWin::ApplySettings(vcl::RenderContext& rRenderContext)
2662 {
2663 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
2664
2665 ApplyControlFont(rRenderContext, rStyleSettings.GetFieldFont());
2666 ApplyControlForeground(rRenderContext, rStyleSettings.GetFieldTextColor());
2667
2668 if (IsControlBackground())
2669 rRenderContext.SetBackground(GetControlBackground());
2670 else
2671 rRenderContext.SetBackground(rStyleSettings.GetFieldColor());
2672 }
2673
2674 void ImplWin::Paint( vcl::RenderContext& rRenderContext, const tools::Rectangle& )
2675 {
2676 ImplDraw(rRenderContext);
2677 }
2678
2679 void ImplWin::DrawEntry(vcl::RenderContext& rRenderContext, bool bLayout)
2680 {
2681 tools::Long nBorder = 1;
2682 Size aOutSz(GetOutputSizePixel());
2683
2684 bool bImage = !!maImage;
2685 if (bImage && !bLayout)
2686 {
2687 DrawImageFlags nStyle = DrawImageFlags::NONE;
2688 Size aImgSz = maImage.GetSizePixel();
2689 Point aPtImg( nBorder, ( ( aOutSz.Height() - aImgSz.Height() ) / 2 ) );
2690 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
2691
2692 // check for HC mode
2693 Image *pImage = &maImage;
2694
2695 if ( !IsZoom() )
2696 {
2697 rRenderContext.DrawImage( aPtImg, *pImage, nStyle );
2698 }
2699 else
2700 {
2701 aImgSz.setWidth( CalcZoom( aImgSz.Width() ) );
2702 aImgSz.setHeight( CalcZoom( aImgSz.Height() ) );
2703 rRenderContext.DrawImage( aPtImg, aImgSz, *pImage, nStyle );
2704 }
2705
2706 const sal_uInt16 nEdgeBlendingPercent(GetEdgeBlending() ? rStyleSettings.GetEdgeBlending() : 0);
2707
2708 if(nEdgeBlendingPercent)
2709 {
2710 const Color& rTopLeft(rStyleSettings.GetEdgeBlendingTopLeftColor());
2711 const Color& rBottomRight(rStyleSettings.GetEdgeBlendingBottomRightColor());
2712 const sal_uInt8 nAlpha(255 - ((nEdgeBlendingPercent * 255) / 100));
2713 const BitmapEx aBlendFrame(createAlphaBlendFrame(aImgSz, nAlpha, rTopLeft, rBottomRight));
2714
2715 if(!aBlendFrame.IsEmpty())
2716 {
2717 rRenderContext.DrawBitmapEx(aPtImg, aBlendFrame);
2718 }
2719 }
2720 }
2721
2722 if( !maString.isEmpty() )
2723 {
2724 DrawTextFlags nTextStyle = DrawTextFlags::VCenter;
2725
2726 if ( bImage && !bLayout )
2727 nTextStyle |= DrawTextFlags::Left;
2728 else if ( GetStyle() & WB_CENTER )
2729 nTextStyle |= DrawTextFlags::Center;
2730 else if ( GetStyle() & WB_RIGHT )
2731 nTextStyle |= DrawTextFlags::Right;
2732 else
2733 nTextStyle |= DrawTextFlags::Left;
2734
2735 tools::Rectangle aTextRect( Point( nBorder, 0 ), Size( aOutSz.Width()-2*nBorder, aOutSz.Height() ) );
2736
2737 if ( bImage )
2738 {
2739 aTextRect.AdjustLeft(maImage.GetSizePixel().Width() + IMG_TXT_DISTANCE );
2740 }
2741
2742 std::vector< tools::Rectangle >* pVector = bLayout ? &mxLayoutData->m_aUnicodeBoundRects : nullptr;
2743 OUString* pDisplayText = bLayout ? &mxLayoutData->m_aDisplayText : nullptr;
2744 rRenderContext.DrawText( aTextRect, maString, nTextStyle, pVector, pDisplayText );
2745 }
2746
2747 if( HasFocus() && !bLayout )
2748 ShowFocus( maFocusRect );
2749 }
2750
2751 void ImplWin::Resize()
2752 {
2753 Control::Resize();
2754 maFocusRect.SetSize( GetOutputSizePixel() );
2755 Invalidate();
2756 }
2757
2758 void ImplWin::GetFocus()
2759 {
2760 ShowFocus( maFocusRect );
2761 if (IsNativeWidgetEnabled() &&
2762 IsNativeControlSupported(ControlType::Listbox, ControlPart::Entire))
2763 {
2764 vcl::Window* pWin = GetParent()->GetWindow( GetWindowType::Border );
2765 if( ! pWin )
2766 pWin = GetParent();
2767 pWin->Invalidate();
2768 }
2769 else
2770 Invalidate();
2771 Control::GetFocus();
2772 }
2773
2774 void ImplWin::LoseFocus()
2775 {
2776 HideFocus();
2777 if (IsNativeWidgetEnabled() &&
2778 IsNativeControlSupported( ControlType::Listbox, ControlPart::Entire))
2779 {
2780 vcl::Window* pWin = GetParent()->GetWindow( GetWindowType::Border );
2781 if( ! pWin )
2782 pWin = GetParent();
2783 pWin->Invalidate();
2784 }
2785 else
2786 Invalidate();
2787 Control::LoseFocus();
2788 }
2789
2790 void ImplWin::ShowFocus(const tools::Rectangle& rRect)
2791 {
2792 if (IsNativeControlSupported(ControlType::Listbox, ControlPart::Focus))
2793 {
2794 ImplControlValue aControlValue;
2795
2796 vcl::Window *pWin = GetParent();
2797 tools::Rectangle aParentRect(Point(0, 0), pWin->GetSizePixel());
2798 pWin->GetOutDev()->DrawNativeControl(ControlType::Listbox, ControlPart::Focus, aParentRect,
2799 ControlState::FOCUSED, aControlValue, OUString());
2800 }
2801 Control::ShowFocus(rRect);
2802 }
2803
2804 ImplBtn::ImplBtn( vcl::Window* pParent, WinBits nWinStyle ) :
2805 PushButton( pParent, nWinStyle )
2806 {
2807 }
2808
2809 void ImplBtn::MouseButtonDown( const MouseEvent& )
2810 {
2811 if( IsEnabled() )
2812 maMBDownHdl.Call(this);
2813 }
2814
2815 ImplListBoxFloatingWindow::ImplListBoxFloatingWindow( vcl::Window* pParent ) :
2816 FloatingWindow( pParent, WB_BORDER | WB_SYSTEMWINDOW | WB_NOSHADOW ) // no drop shadow for list boxes
2817 {
2818 // for native widget rendering we must be able to detect this window type
2819 SetType( WindowType::LISTBOXWINDOW );
2820
2821 mpImplLB = nullptr;
2822 mnDDLineCount = 0;
2823 mbAutoWidth = false;
2824
2825 mnPopupModeStartSaveSelection = LISTBOX_ENTRY_NOTFOUND;
2826
2827 vcl::Window * pBorderWindow = ImplGetBorderWindow();
2828 if( pBorderWindow )
2829 {
2830 SetAccessibleRole(accessibility::AccessibleRole::PANEL);
2831 pBorderWindow->SetAccessibleRole(accessibility::AccessibleRole::WINDOW);
2832 }
2833 else
2834 {
2835 SetAccessibleRole(accessibility::AccessibleRole::WINDOW);
2836 }
2837
2838 }
2839
2840 ImplListBoxFloatingWindow::~ImplListBoxFloatingWindow()
2841 {
2842 disposeOnce();
2843 }
2844
2845 void ImplListBoxFloatingWindow::dispose()
2846 {
2847 mpImplLB.clear();
2848 FloatingWindow::dispose();
2849 }
2850
2851
2852 bool ImplListBoxFloatingWindow::PreNotify( NotifyEvent& rNEvt )
2853 {
2854 if( rNEvt.GetType() == NotifyEventType::LOSEFOCUS )
2855 {
2856 if( !GetParent()->HasChildPathFocus( true ) )
2857 EndPopupMode();
2858 }
2859
2860 return FloatingWindow::PreNotify( rNEvt );
2861 }
2862
2863 void ImplListBoxFloatingWindow::setPosSizePixel( tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight, PosSizeFlags nFlags )
2864 {
2865 FloatingWindow::setPosSizePixel( nX, nY, nWidth, nHeight, nFlags );
2866
2867 // Fix #60890# ( MBA ): to be able to resize the Listbox even in its open state
2868 // after a call to Resize(), we adjust its position if necessary
2869 if ( IsReallyVisible() && ( nFlags & PosSizeFlags::Height ) )
2870 {
2871 Point aPos = GetParent()->GetPosPixel();
2872 aPos = GetParent()->GetParent()->OutputToScreenPixel( aPos );
2873
2874 if ( nFlags & PosSizeFlags::X )
2875 aPos.setX( nX );
2876
2877 if ( nFlags & PosSizeFlags::Y )
2878 aPos.setY( nY );
2879
2880 sal_uInt16 nIndex;
2881 SetPosPixel( ImplCalcPos( this, tools::Rectangle( aPos, GetParent()->GetSizePixel() ), FloatWinPopupFlags::Down, nIndex ) );
2882 }
2883
2884 // if( !IsReallyVisible() )
2885 {
2886 // The ImplListBox does not get a Resize() as not visible.
2887 // But the windows must get a Resize(), so that the number of
2888 // visible entries is correct for PgUp/PgDown.
2889 // The number also cannot be calculated by List/Combobox, as for
2890 // this the presence of the vertical Scrollbar has to be known.
2891 mpImplLB->SetSizePixel( GetOutputSizePixel() );
2892 static_cast<vcl::Window*>(mpImplLB)->Resize();
2893 static_cast<vcl::Window*>(mpImplLB->GetMainWindow())->Resize();
2894 }
2895 }
2896
2897 void ImplListBoxFloatingWindow::Resize()
2898 {
2899 mpImplLB->GetMainWindow()->ImplClearLayoutData();
2900 FloatingWindow::Resize();
2901 }
2902
2903 Size ImplListBoxFloatingWindow::CalcFloatSize() const
2904 {
2905 Size aFloatSz( maPrefSz );
2906
2907 sal_Int32 nLeft, nTop, nRight, nBottom;
2908 GetBorder( nLeft, nTop, nRight, nBottom );
2909
2910 sal_Int32 nLines = mpImplLB->GetEntryList().GetEntryCount();
2911 if ( mnDDLineCount && ( nLines > mnDDLineCount ) )
2912 nLines = mnDDLineCount;
2913
2914 Size aSz = mpImplLB->CalcSize( nLines );
2915 tools::Long nMaxHeight = aSz.Height() + nTop + nBottom;
2916
2917 if ( mnDDLineCount )
2918 aFloatSz.setHeight( nMaxHeight );
2919
2920 if( mbAutoWidth )
2921 {
2922 // AutoSize first only for width...
2923
2924 aFloatSz.setWidth( aSz.Width() + nLeft + nRight );
2925 aFloatSz.AdjustWidth(nRight ); // adding some space looks better...
2926
2927 if ( ( aFloatSz.Height() < nMaxHeight ) || ( mnDDLineCount && ( mnDDLineCount < mpImplLB->GetEntryList().GetEntryCount() ) ) )
2928 {
2929 // then we also need the vertical Scrollbar
2930 tools::Long nSBWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
2931 aFloatSz.AdjustWidth(nSBWidth );
2932 }
2933
2934 tools::Long nDesktopWidth = GetDesktopRectPixel().getOpenWidth();
2935 if (aFloatSz.Width() > nDesktopWidth)
2936 // Don't exceed the desktop width.
2937 aFloatSz.setWidth( nDesktopWidth );
2938 }
2939
2940 if ( aFloatSz.Height() > nMaxHeight )
2941 aFloatSz.setHeight( nMaxHeight );
2942
2943 // Minimal height, in case height is not set to Float height.
2944 // The parent of FloatWin must be DropDown-Combo/Listbox.
2945 Size aParentSz = GetParent()->GetSizePixel();
2946 if( (!mnDDLineCount || !nLines) && ( aFloatSz.Height() < aParentSz.Height() ) )
2947 aFloatSz.setHeight( aParentSz.Height() );
2948
2949 // do not get narrower than the parent...
2950 if( aFloatSz.Width() < aParentSz.Width() )
2951 aFloatSz.setWidth( aParentSz.Width() );
2952
2953 // align height to entries...
2954 tools::Long nInnerHeight = aFloatSz.Height() - nTop - nBottom;
2955 tools::Long nEntryHeight = mpImplLB->GetEntryHeightWithMargin();
2956 if ( nInnerHeight % nEntryHeight )
2957 {
2958 nInnerHeight /= nEntryHeight;
2959 nInnerHeight++;
2960 nInnerHeight *= nEntryHeight;
2961 aFloatSz.setHeight( nInnerHeight + nTop + nBottom );
2962 }
2963
2964 if (aFloatSz.Width() < aSz.Width())
2965 {
2966 // The max width of list box entries exceeds the window width.
2967 // Account for the scroll bar height.
2968 tools::Long nSBWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
2969 aFloatSz.AdjustHeight(nSBWidth );
2970 }
2971
2972 return aFloatSz;
2973 }
2974
2975 void ImplListBoxFloatingWindow::StartFloat( bool bStartTracking )
2976 {
2977 if( IsInPopupMode() )
2978 return;
2979
2980 Size aFloatSz = CalcFloatSize();
2981
2982 SetSizePixel( aFloatSz );
2983 mpImplLB->SetSizePixel( GetOutputSizePixel() );
2984
2985 sal_Int32 nPos = mpImplLB->GetEntryList().GetSelectedEntryPos( 0 );
2986 mnPopupModeStartSaveSelection = nPos;
2987
2988 Size aSz = GetParent()->GetSizePixel();
2989 Point aPos = GetParent()->GetPosPixel();
2990 aPos = GetParent()->GetParent()->OutputToScreenPixel( aPos );
2991 // FIXME: this ugly hack is for Mac/Aqua
2992 // should be replaced by a real mechanism to place the float rectangle
2993 if( ImplGetSVData()->maNWFData.mbNoFocusRects &&
2994 GetParent()->IsNativeWidgetEnabled() )
2995 {
2996 const sal_Int32 nLeft = 4, nTop = 4, nRight = 4, nBottom = 4;
2997 aPos.AdjustX(nLeft );
2998 aPos.AdjustY(nTop );
2999 aSz.AdjustWidth( -(nLeft + nRight) );
3000 aSz.AdjustHeight( -(nTop + nBottom) );
3001 }
3002 tools::Rectangle aRect( aPos, aSz );
3003
3004 // check if the control's parent is un-mirrored which is the case for form controls in a mirrored UI
3005 // where the document is unmirrored
3006 // because StartPopupMode() expects a rectangle in mirrored coordinates we have to re-mirror
3007 vcl::Window *pGrandparent = GetParent()->GetParent();
3008 const OutputDevice *pGrandparentOutDev = pGrandparent->GetOutDev();
3009
3010 if( pGrandparent->GetOutDev()->ImplIsAntiparallel() )
3011 pGrandparentOutDev->ReMirror( aRect );
3012
3013 // mouse-button right: close the List-Box-Float-win and don't stop the handling fdo#84795
3014 StartPopupMode( aRect, LISTBOX_FLOATWINPOPUPFLAGS );
3015
3016 if( nPos != LISTBOX_ENTRY_NOTFOUND )
3017 mpImplLB->ShowProminentEntry( nPos );
3018
3019 if( bStartTracking )
3020 mpImplLB->GetMainWindow()->EnableMouseMoveSelect( true );
3021
3022 if ( mpImplLB->GetMainWindow()->IsGrabFocusAllowed() )
3023 mpImplLB->GetMainWindow()->GrabFocus();
3024
3025 mpImplLB->GetMainWindow()->ImplClearLayoutData();
3026
3027 }
3028
3029 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE