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