Line data Source code
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 <tools/debug.hxx>
21 : #include <vcl/decoview.hxx>
22 : #include <vcl/svapp.hxx>
23 : #include <vcl/scrbar.hxx>
24 : #include <vcl/help.hxx>
25 : #include <com/sun/star/accessibility/AccessibleEventObject.hpp>
26 : #include <com/sun/star/accessibility/AccessibleEventId.hpp>
27 : #include <com/sun/star/accessibility/AccessibleStateType.hpp>
28 : #include <com/sun/star/lang/XComponent.hpp>
29 : #include <rtl/ustring.hxx>
30 :
31 : #include "valueimp.hxx"
32 :
33 : #define _SV_VALUESET_CXX
34 : #include <svtools/valueset.hxx>
35 :
36 : namespace
37 : {
38 :
39 : enum {
40 : ITEM_OFFSET = 4,
41 : ITEM_OFFSET_DOUBLE = 6,
42 : NAME_LINE_OFF_X = 2,
43 : NAME_LINE_OFF_Y = 2,
44 : NAME_LINE_HEIGHT = 2,
45 : NAME_OFFSET = 2,
46 : SCRBAR_OFFSET = 1,
47 : SCROLL_OFFSET = 4
48 : };
49 :
50 : }
51 :
52 : // ------------
53 : // - ValueSet -
54 : // ------------
55 :
56 0 : void ValueSet::ImplInit()
57 : {
58 0 : mpNoneItem = NULL;
59 0 : mpScrBar = NULL;
60 0 : mnItemWidth = 0;
61 0 : mnItemHeight = 0;
62 0 : mnTextOffset = 0;
63 0 : mnVisLines = 0;
64 0 : mnLines = 0;
65 0 : mnUserItemWidth = 0;
66 0 : mnUserItemHeight = 0;
67 0 : mnFirstLine = 0;
68 0 : mnSelItemId = 0;
69 0 : mnHighItemId = 0;
70 0 : mnCols = 0;
71 0 : mnCurCol = 0;
72 0 : mnUserCols = 0;
73 0 : mnUserVisLines = 0;
74 0 : mnSpacing = 0;
75 0 : mnFrameStyle = 0;
76 0 : mbFormat = true;
77 0 : mbHighlight = false;
78 0 : mbSelection = false;
79 0 : mbNoSelection = true;
80 0 : mbDrawSelection = true;
81 0 : mbBlackSel = false;
82 0 : mbDoubleSel = false;
83 0 : mbScroll = false;
84 0 : mbFullMode = true;
85 0 : mbHasVisibleItems = false;
86 :
87 : // #106446#, #106601# force mirroring of virtual device
88 0 : maVirDev.EnableRTL( GetParent()->IsRTLEnabled() );
89 :
90 0 : ImplInitSettings( true, true, true );
91 0 : }
92 :
93 : // -----------------------------------------------------------------------
94 :
95 0 : ValueSet::ValueSet( Window* pParent, WinBits nWinStyle, bool bDisableTransientChildren ) :
96 : Control( pParent, nWinStyle ),
97 : maVirDev( *this ),
98 0 : maColor( COL_TRANSPARENT )
99 : {
100 0 : ImplInit();
101 0 : mbIsTransientChildrenDisabled = bDisableTransientChildren;
102 0 : }
103 :
104 : // -----------------------------------------------------------------------
105 :
106 0 : ValueSet::ValueSet( Window* pParent, const ResId& rResId, bool bDisableTransientChildren ) :
107 : Control( pParent, rResId ),
108 : maVirDev( *this ),
109 0 : maColor( COL_TRANSPARENT )
110 : {
111 0 : ImplInit();
112 0 : mbIsTransientChildrenDisabled = bDisableTransientChildren;
113 0 : }
114 :
115 : // -----------------------------------------------------------------------
116 :
117 0 : ValueSet::~ValueSet()
118 : {
119 : ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent>
120 0 : xComponent (GetAccessible(sal_False), ::com::sun::star::uno::UNO_QUERY);
121 0 : if (xComponent.is())
122 0 : xComponent->dispose ();
123 :
124 0 : delete mpScrBar;
125 0 : delete mpNoneItem;
126 :
127 0 : ImplDeleteItems();
128 0 : }
129 :
130 : // -----------------------------------------------------------------------
131 :
132 0 : void ValueSet::ImplDeleteItems()
133 : {
134 0 : const size_t n = mItemList.size();
135 :
136 0 : for ( size_t i = 0; i < n; ++i )
137 : {
138 0 : ValueSetItem *const pItem = mItemList[i];
139 0 : if ( pItem->mbVisible && ImplHasAccessibleListeners() )
140 : {
141 0 : ::com::sun::star::uno::Any aOldAny, aNewAny;
142 :
143 0 : aOldAny <<= pItem->GetAccessible( mbIsTransientChildrenDisabled );
144 0 : ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
145 : }
146 :
147 0 : delete pItem;
148 : }
149 :
150 0 : mItemList.clear();
151 0 : }
152 :
153 : // -----------------------------------------------------------------------
154 :
155 0 : void ValueSet::ImplInitSettings( bool bFont, bool bForeground, bool bBackground )
156 : {
157 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
158 :
159 0 : if ( bFont )
160 : {
161 0 : Font aFont;
162 0 : aFont = rStyleSettings.GetAppFont();
163 0 : if ( IsControlFont() )
164 0 : aFont.Merge( GetControlFont() );
165 0 : SetZoomedPointFont( aFont );
166 : }
167 :
168 0 : if ( bForeground || bFont )
169 : {
170 0 : Color aColor;
171 0 : if ( IsControlForeground() )
172 0 : aColor = GetControlForeground();
173 : else
174 0 : aColor = rStyleSettings.GetButtonTextColor();
175 0 : SetTextColor( aColor );
176 0 : SetTextFillColor();
177 : }
178 :
179 0 : if ( bBackground )
180 : {
181 0 : Color aColor;
182 0 : if ( IsControlBackground() )
183 0 : aColor = GetControlBackground();
184 0 : else if ( GetStyle() & WB_MENUSTYLEVALUESET )
185 0 : aColor = rStyleSettings.GetMenuColor();
186 0 : else if ( IsEnabled() && (GetStyle() & WB_FLATVALUESET) )
187 0 : aColor = rStyleSettings.GetWindowColor();
188 : else
189 0 : aColor = rStyleSettings.GetFaceColor();
190 0 : SetBackground( aColor );
191 : }
192 0 : }
193 :
194 : // -----------------------------------------------------------------------
195 :
196 0 : void ValueSet::ImplInitScrollBar()
197 : {
198 0 : if ( GetStyle() & WB_VSCROLL )
199 : {
200 0 : if ( !mpScrBar )
201 : {
202 0 : mpScrBar = new ScrollBar( this, WB_VSCROLL | WB_DRAG );
203 0 : mpScrBar->SetScrollHdl( LINK( this, ValueSet, ImplScrollHdl ) );
204 : }
205 : else
206 : {
207 : // adapt the width because of the changed settings
208 0 : long nScrBarWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
209 0 : mpScrBar->setPosSizePixel( 0, 0, nScrBarWidth, 0, WINDOW_POSSIZE_WIDTH );
210 : }
211 : }
212 0 : }
213 :
214 : // -----------------------------------------------------------------------
215 :
216 0 : void ValueSet::ImplFormatItem( ValueSetItem* pItem, Rectangle aRect )
217 : {
218 0 : WinBits nStyle = GetStyle();
219 0 : if ( nStyle & WB_ITEMBORDER )
220 : {
221 0 : aRect.Left()++;
222 0 : aRect.Top()++;
223 0 : aRect.Right()--;
224 0 : aRect.Bottom()--;
225 0 : if ( nStyle & WB_FLATVALUESET )
226 : {
227 0 : if ( nStyle & WB_DOUBLEBORDER )
228 : {
229 0 : aRect.Left() += 2;
230 0 : aRect.Top() += 2;
231 0 : aRect.Right() -= 2;
232 0 : aRect.Bottom() -= 2;
233 : }
234 : else
235 : {
236 0 : aRect.Left()++;
237 0 : aRect.Top()++;
238 0 : aRect.Right()--;
239 0 : aRect.Bottom()--;
240 : }
241 : }
242 : else
243 : {
244 0 : DecorationView aView( &maVirDev );
245 0 : aRect = aView.DrawFrame( aRect, mnFrameStyle );
246 : }
247 : }
248 :
249 0 : if ( pItem == mpNoneItem )
250 0 : pItem->maText = GetText();
251 :
252 0 : if ( (aRect.GetHeight() > 0) && (aRect.GetWidth() > 0) )
253 : {
254 0 : if ( pItem == mpNoneItem )
255 : {
256 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
257 0 : maVirDev.SetFont( GetFont() );
258 0 : maVirDev.SetTextColor( ( nStyle & WB_MENUSTYLEVALUESET ) ? rStyleSettings.GetMenuTextColor() : rStyleSettings.GetWindowTextColor() );
259 0 : maVirDev.SetTextFillColor();
260 0 : maVirDev.SetFillColor( ( nStyle & WB_MENUSTYLEVALUESET ) ? rStyleSettings.GetMenuColor() : rStyleSettings.GetWindowColor() );
261 0 : maVirDev.DrawRect( aRect );
262 0 : Point aTxtPos( aRect.Left()+2, aRect.Top() );
263 0 : long nTxtWidth = GetTextWidth( pItem->maText );
264 0 : if ( nStyle & WB_RADIOSEL )
265 : {
266 0 : aTxtPos.X() += 4;
267 0 : aTxtPos.Y() += 4;
268 : }
269 0 : if ( (aTxtPos.X()+nTxtWidth) > aRect.Right() )
270 : {
271 0 : maVirDev.SetClipRegion( Region( aRect ) );
272 0 : maVirDev.DrawText( aTxtPos, pItem->maText );
273 0 : maVirDev.SetClipRegion();
274 : }
275 : else
276 0 : maVirDev.DrawText( aTxtPos, pItem->maText );
277 : }
278 0 : else if ( pItem->meType == VALUESETITEM_COLOR )
279 : {
280 0 : maVirDev.SetFillColor( pItem->maColor );
281 0 : maVirDev.DrawRect( aRect );
282 : }
283 : else
284 : {
285 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
286 0 : if ( IsColor() )
287 0 : maVirDev.SetFillColor( maColor );
288 0 : else if ( nStyle & WB_MENUSTYLEVALUESET )
289 0 : maVirDev.SetFillColor( rStyleSettings.GetMenuColor() );
290 0 : else if ( IsEnabled() )
291 0 : maVirDev.SetFillColor( rStyleSettings.GetWindowColor() );
292 : else
293 0 : maVirDev.SetFillColor( rStyleSettings.GetFaceColor() );
294 0 : maVirDev.DrawRect( aRect );
295 :
296 0 : if ( pItem->meType == VALUESETITEM_USERDRAW )
297 : {
298 0 : UserDrawEvent aUDEvt( &maVirDev, aRect, pItem->mnId );
299 0 : UserDraw( aUDEvt );
300 : }
301 : else
302 : {
303 0 : Size aImageSize = pItem->maImage.GetSizePixel();
304 0 : Size aRectSize = aRect.GetSize();
305 0 : Point aPos( aRect.Left(), aRect.Top() );
306 0 : aPos.X() += (aRectSize.Width()-aImageSize.Width())/2;
307 0 : aPos.Y() += (aRectSize.Height()-aImageSize.Height())/2;
308 :
309 0 : sal_uInt16 nImageStyle = 0;
310 0 : if( !IsEnabled() )
311 0 : nImageStyle |= IMAGE_DRAW_DISABLE;
312 :
313 0 : if ( (aImageSize.Width() > aRectSize.Width()) ||
314 0 : (aImageSize.Height() > aRectSize.Height()) )
315 : {
316 0 : maVirDev.SetClipRegion( Region( aRect ) );
317 0 : maVirDev.DrawImage( aPos, pItem->maImage, nImageStyle);
318 0 : maVirDev.SetClipRegion();
319 : }
320 : else
321 0 : maVirDev.DrawImage( aPos, pItem->maImage, nImageStyle );
322 : }
323 : }
324 : }
325 0 : }
326 :
327 : // -----------------------------------------------------------------------
328 :
329 0 : ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > ValueSet::CreateAccessible()
330 : {
331 0 : return new ValueSetAcc( this, mbIsTransientChildrenDisabled );
332 : }
333 :
334 : // -----------------------------------------------------------------------
335 :
336 0 : void ValueSet::Format()
337 : {
338 0 : Size aWinSize = GetOutputSizePixel();
339 0 : size_t nItemCount = mItemList.size();
340 0 : WinBits nStyle = GetStyle();
341 0 : long nTxtHeight = GetTextHeight();
342 : long nOff;
343 : long nNoneHeight;
344 : long nNoneSpace;
345 0 : ScrollBar* pDelScrBar = NULL;
346 :
347 : // consider the scrolling
348 0 : if ( nStyle & WB_VSCROLL )
349 0 : ImplInitScrollBar();
350 : else
351 : {
352 0 : if ( mpScrBar )
353 : {
354 : // delete ScrollBar not until later, to prevent recursive calls
355 0 : pDelScrBar = mpScrBar;
356 0 : mpScrBar = NULL;
357 : }
358 : }
359 :
360 : // calculate item offset
361 0 : if ( nStyle & WB_ITEMBORDER )
362 : {
363 0 : if ( nStyle & WB_DOUBLEBORDER )
364 0 : nOff = ITEM_OFFSET_DOUBLE;
365 : else
366 0 : nOff = ITEM_OFFSET;
367 : }
368 : else
369 0 : nOff = 0;
370 :
371 : // consider size, if NameField does exist
372 0 : if ( nStyle & WB_NAMEFIELD )
373 : {
374 0 : mnTextOffset = aWinSize.Height()-nTxtHeight-NAME_OFFSET;
375 0 : aWinSize.Height() -= nTxtHeight+NAME_OFFSET;
376 :
377 0 : if ( !(nStyle & WB_FLATVALUESET) )
378 : {
379 0 : mnTextOffset -= NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
380 0 : aWinSize.Height() -= NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
381 : }
382 : }
383 : else
384 0 : mnTextOffset = 0;
385 :
386 : // consider offset and size, if NoneField does exist
387 0 : if ( nStyle & WB_NONEFIELD )
388 : {
389 0 : nNoneHeight = nTxtHeight+nOff;
390 0 : nNoneSpace = mnSpacing;
391 0 : if ( nStyle & WB_RADIOSEL )
392 0 : nNoneHeight += 8;
393 : }
394 : else
395 : {
396 0 : nNoneHeight = 0;
397 0 : nNoneSpace = 0;
398 :
399 0 : if ( mpNoneItem )
400 : {
401 0 : delete mpNoneItem;
402 0 : mpNoneItem = NULL;
403 : }
404 : }
405 :
406 : // calculate ScrollBar width
407 0 : long nScrBarWidth = 0;
408 0 : if ( mpScrBar )
409 0 : nScrBarWidth = mpScrBar->GetSizePixel().Width()+SCRBAR_OFFSET;
410 :
411 : // calculate number of columns
412 0 : if ( !mnUserCols )
413 : {
414 0 : if ( mnUserItemWidth )
415 : {
416 0 : mnCols = (sal_uInt16)((aWinSize.Width()-nScrBarWidth+mnSpacing) / (mnUserItemWidth+mnSpacing));
417 0 : if ( !mnCols )
418 0 : mnCols = 1;
419 : }
420 : else
421 0 : mnCols = 1;
422 : }
423 : else
424 0 : mnCols = mnUserCols;
425 :
426 : // calculate number of rows
427 0 : mbScroll = false;
428 : // Floor( (M+N-1)/N )==Ceiling( M/N )
429 0 : mnLines = (static_cast<long>(nItemCount)+mnCols-1) / mnCols;
430 0 : if ( !mnLines )
431 0 : mnLines = 1;
432 :
433 0 : long nCalcHeight = aWinSize.Height()-nNoneHeight;
434 0 : if ( mnUserVisLines )
435 0 : mnVisLines = mnUserVisLines;
436 0 : else if ( mnUserItemHeight )
437 : {
438 0 : mnVisLines = (nCalcHeight-nNoneSpace+mnSpacing) / (mnUserItemHeight+mnSpacing);
439 0 : if ( !mnVisLines )
440 0 : mnVisLines = 1;
441 : }
442 : else
443 0 : mnVisLines = mnLines;
444 0 : if ( mnLines > mnVisLines )
445 0 : mbScroll = true;
446 0 : if ( mnLines <= mnVisLines )
447 0 : mnFirstLine = 0;
448 : else
449 : {
450 0 : if ( mnFirstLine > (sal_uInt16)(mnLines-mnVisLines) )
451 0 : mnFirstLine = (sal_uInt16)(mnLines-mnVisLines);
452 : }
453 :
454 : // calculate item size
455 0 : const long nColSpace = (mnCols-1)*mnSpacing;
456 0 : const long nLineSpace = ((mnVisLines-1)*mnSpacing)+nNoneSpace;
457 0 : if ( mnUserItemWidth && !mnUserCols )
458 : {
459 0 : mnItemWidth = mnUserItemWidth;
460 0 : if ( mnItemWidth > aWinSize.Width()-nScrBarWidth-nColSpace )
461 0 : mnItemWidth = aWinSize.Width()-nScrBarWidth-nColSpace;
462 : }
463 : else
464 0 : mnItemWidth = (aWinSize.Width()-nScrBarWidth-nColSpace) / mnCols;
465 0 : if ( mnUserItemHeight && !mnUserVisLines )
466 : {
467 0 : mnItemHeight = mnUserItemHeight;
468 0 : if ( mnItemHeight > nCalcHeight-nNoneSpace )
469 0 : mnItemHeight = nCalcHeight-nNoneSpace;
470 : }
471 : else
472 : {
473 0 : nCalcHeight -= nLineSpace;
474 0 : mnItemHeight = nCalcHeight / mnVisLines;
475 : }
476 :
477 : // Init VirDev
478 0 : maVirDev.SetSettings( GetSettings() );
479 0 : maVirDev.SetBackground( GetBackground() );
480 0 : maVirDev.SetOutputSizePixel( aWinSize, sal_True );
481 :
482 : // nothing is changed in case of too small items
483 0 : if ( (mnItemWidth <= 0) ||
484 : (mnItemHeight <= (( nStyle & WB_ITEMBORDER ) ? 4 : 2)) ||
485 : !nItemCount )
486 : {
487 0 : mbHasVisibleItems = false;
488 :
489 0 : if ( nStyle & WB_NONEFIELD )
490 : {
491 0 : if ( mpNoneItem )
492 : {
493 0 : mpNoneItem->mbVisible = false;
494 0 : mpNoneItem->maText = GetText();
495 : }
496 : }
497 :
498 0 : for ( size_t i = 0; i < nItemCount; i++ )
499 : {
500 0 : mItemList[i]->mbVisible = false;
501 : }
502 :
503 0 : if ( mpScrBar )
504 0 : mpScrBar->Hide();
505 : }
506 : else
507 : {
508 0 : mbHasVisibleItems = true;
509 :
510 : // determine Frame-Style
511 0 : if ( nStyle & WB_DOUBLEBORDER )
512 0 : mnFrameStyle = FRAME_DRAW_DOUBLEIN;
513 : else
514 0 : mnFrameStyle = FRAME_DRAW_IN;
515 :
516 : // determine selected color and width
517 : // if necessary change the colors, to make the selection
518 : // better detectable
519 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
520 0 : Color aHighColor( rStyleSettings.GetHighlightColor() );
521 0 : if ( ((aHighColor.GetRed() > 0x80) || (aHighColor.GetGreen() > 0x80) ||
522 0 : (aHighColor.GetBlue() > 0x80)) ||
523 0 : ((aHighColor.GetRed() == 0x80) && (aHighColor.GetGreen() == 0x80) &&
524 0 : (aHighColor.GetBlue() == 0x80)) )
525 0 : mbBlackSel = true;
526 : else
527 0 : mbBlackSel = false;
528 :
529 : // draw the selection with double width if the items are bigger
530 0 : if ( (nStyle & WB_DOUBLEBORDER) &&
531 : ((mnItemWidth >= 25) && (mnItemHeight >= 20)) )
532 0 : mbDoubleSel = true;
533 : else
534 0 : mbDoubleSel = false;
535 :
536 : // calculate offsets
537 : long nStartX;
538 : long nStartY;
539 0 : if ( mbFullMode )
540 : {
541 0 : long nAllItemWidth = (mnItemWidth*mnCols)+nColSpace;
542 0 : long nAllItemHeight = (mnItemHeight*mnVisLines)+nNoneHeight+nLineSpace;
543 0 : nStartX = (aWinSize.Width()-nScrBarWidth-nAllItemWidth)/2;
544 0 : nStartY = (aWinSize.Height()-nAllItemHeight)/2;
545 : }
546 : else
547 : {
548 0 : nStartX = 0;
549 0 : nStartY = 0;
550 : }
551 :
552 : // calculate and draw items
553 0 : maVirDev.SetLineColor();
554 0 : long x = nStartX;
555 0 : long y = nStartY;
556 :
557 : // create NoSelection field and show it
558 0 : if ( nStyle & WB_NONEFIELD )
559 : {
560 0 : if ( !mpNoneItem )
561 0 : mpNoneItem = new ValueSetItem( *this );
562 :
563 0 : mpNoneItem->mnId = 0;
564 0 : mpNoneItem->meType = VALUESETITEM_NONE;
565 0 : mpNoneItem->mbVisible = true;
566 0 : maNoneItemRect.Left() = x;
567 0 : maNoneItemRect.Top() = y;
568 0 : maNoneItemRect.Right() = maNoneItemRect.Left()+aWinSize.Width()-x-1;
569 0 : maNoneItemRect.Bottom() = y+nNoneHeight-1;
570 :
571 0 : ImplFormatItem( mpNoneItem, maNoneItemRect );
572 :
573 0 : y += nNoneHeight+nNoneSpace;
574 : }
575 :
576 : // draw items
577 0 : sal_uLong nFirstItem = mnFirstLine * mnCols;
578 0 : sal_uLong nLastItem = nFirstItem + (mnVisLines * mnCols);
579 :
580 0 : maItemListRect.Left() = x;
581 0 : maItemListRect.Top() = y;
582 0 : maItemListRect.Right() = x + mnCols*(mnItemWidth+mnSpacing) - mnSpacing - 1;
583 0 : maItemListRect.Bottom() = y + mnVisLines*(mnItemHeight+mnSpacing) - mnSpacing - 1;
584 :
585 0 : if ( !mbFullMode )
586 : {
587 : // If want also draw parts of items in the last line,
588 : // then we add one more line if parts of these line are
589 : // visible
590 0 : if ( y+(mnVisLines*(mnItemHeight+mnSpacing)) < aWinSize.Height() )
591 0 : nLastItem += mnCols;
592 0 : maItemListRect.Bottom() = aWinSize.Height() - y;
593 : }
594 0 : for ( size_t i = 0; i < nItemCount; i++ )
595 : {
596 0 : ValueSetItem *const pItem = mItemList[i];
597 :
598 0 : if ( (i >= nFirstItem) && (i < nLastItem) )
599 : {
600 0 : if( !pItem->mbVisible && ImplHasAccessibleListeners() )
601 : {
602 0 : ::com::sun::star::uno::Any aOldAny, aNewAny;
603 :
604 0 : aNewAny <<= pItem->GetAccessible( mbIsTransientChildrenDisabled );
605 0 : ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
606 : }
607 :
608 0 : pItem->mbVisible = true;
609 0 : ImplFormatItem( pItem, Rectangle( Point(x,y), Size(mnItemWidth, mnItemHeight) ) );
610 :
611 0 : if ( !((i+1) % mnCols) )
612 : {
613 0 : x = nStartX;
614 0 : y += mnItemHeight+mnSpacing;
615 : }
616 : else
617 0 : x += mnItemWidth+mnSpacing;
618 : }
619 : else
620 : {
621 0 : if( pItem->mbVisible && ImplHasAccessibleListeners() )
622 : {
623 0 : ::com::sun::star::uno::Any aOldAny, aNewAny;
624 :
625 0 : aOldAny <<= pItem->GetAccessible( mbIsTransientChildrenDisabled );
626 0 : ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
627 : }
628 :
629 0 : pItem->mbVisible = false;
630 : }
631 : }
632 :
633 : // arrange ScrollBar, set values and show it
634 0 : if ( mpScrBar )
635 : {
636 0 : Point aPos( aWinSize.Width()-nScrBarWidth+SCRBAR_OFFSET, 0 );
637 0 : Size aSize( nScrBarWidth-SCRBAR_OFFSET, aWinSize.Height() );
638 : // If a none field is visible, then we center the scrollbar
639 0 : if ( nStyle & WB_NONEFIELD )
640 : {
641 0 : aPos.Y() = nStartY+nNoneHeight+1;
642 0 : aSize.Height() = ((mnItemHeight+mnSpacing)*mnVisLines)-2-mnSpacing;
643 : }
644 0 : mpScrBar->SetPosSizePixel( aPos, aSize );
645 0 : mpScrBar->SetRangeMax( mnLines );
646 0 : mpScrBar->SetVisibleSize( mnVisLines );
647 0 : mpScrBar->SetThumbPos( (long)mnFirstLine );
648 0 : long nPageSize = mnVisLines;
649 0 : if ( nPageSize < 1 )
650 0 : nPageSize = 1;
651 0 : mpScrBar->SetPageSize( nPageSize );
652 0 : mpScrBar->Show();
653 : }
654 : }
655 :
656 : // waiting for the next since the formatting is finished
657 0 : mbFormat = false;
658 :
659 : // delete ScrollBar
660 0 : delete pDelScrBar;
661 0 : }
662 :
663 : // -----------------------------------------------------------------------
664 :
665 0 : void ValueSet::ImplDrawItemText( const XubString& rText )
666 : {
667 0 : if ( !(GetStyle() & WB_NAMEFIELD) )
668 0 : return;
669 :
670 0 : Size aWinSize = GetOutputSizePixel();
671 0 : long nTxtWidth = GetTextWidth( rText );
672 0 : long nTxtOffset = mnTextOffset;
673 :
674 : // delete rectangle and show text
675 0 : if ( GetStyle() & WB_FLATVALUESET )
676 : {
677 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
678 0 : SetLineColor();
679 0 : SetFillColor( rStyleSettings.GetFaceColor() );
680 0 : DrawRect( Rectangle( Point( 0, nTxtOffset ), Point( aWinSize.Width(), aWinSize.Height() ) ) );
681 0 : SetTextColor( rStyleSettings.GetButtonTextColor() );
682 : }
683 : else
684 : {
685 0 : nTxtOffset += NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
686 0 : Erase( Rectangle( Point( 0, nTxtOffset ), Point( aWinSize.Width(), aWinSize.Height() ) ) );
687 : }
688 0 : DrawText( Point( (aWinSize.Width()-nTxtWidth) / 2, nTxtOffset+(NAME_OFFSET/2) ), rText );
689 : }
690 :
691 : // -----------------------------------------------------------------------
692 :
693 0 : void ValueSet::ImplDrawSelect()
694 : {
695 0 : if ( !IsReallyVisible() )
696 0 : return;
697 :
698 0 : const bool bFocus = HasFocus();
699 0 : const bool bDrawSel = !( (mbNoSelection && !mbHighlight) || (!mbDrawSelection && mbHighlight) );
700 :
701 0 : if ( !bFocus && !bDrawSel )
702 : {
703 0 : XubString aEmptyStr;
704 0 : ImplDrawItemText( aEmptyStr );
705 0 : return;
706 : }
707 :
708 0 : ImplDrawSelect( mnSelItemId, bFocus, bDrawSel );
709 0 : if (mbHighlight)
710 : {
711 0 : ImplDrawSelect( mnHighItemId, bFocus, bDrawSel );
712 : }
713 : }
714 :
715 : // -----------------------------------------------------------------------
716 :
717 0 : void ValueSet::ImplDrawSelect( sal_uInt16 nItemId, const bool bFocus, const bool bDrawSel )
718 : {
719 : ValueSetItem* pItem;
720 0 : Rectangle aRect;
721 0 : if ( nItemId )
722 : {
723 0 : const size_t nPos = GetItemPos( nItemId );
724 0 : pItem = mItemList[ nPos ];
725 0 : aRect = ImplGetItemRect( nPos );
726 : }
727 0 : else if ( mpNoneItem )
728 : {
729 0 : pItem = mpNoneItem;
730 0 : aRect = maNoneItemRect;
731 : }
732 0 : else if ( bFocus && (pItem = ImplGetFirstItem()) )
733 : {
734 0 : aRect = ImplGetItemRect( 0 );
735 : }
736 : else
737 : {
738 0 : return;
739 : }
740 :
741 0 : if ( pItem->mbVisible )
742 : {
743 : // draw selection
744 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
745 0 : Control::SetFillColor();
746 :
747 0 : Color aDoubleColor( rStyleSettings.GetHighlightColor() );
748 0 : Color aSingleColor( rStyleSettings.GetHighlightTextColor() );
749 0 : if( !mbDoubleSel )
750 : {
751 : /*
752 : * #99777# contrast enhancement for thin mode
753 : */
754 0 : const Wallpaper& rWall = GetDisplayBackground();
755 0 : if( ! rWall.IsBitmap() && ! rWall.IsGradient() )
756 : {
757 0 : const Color& rBack = rWall.GetColor();
758 0 : if( rBack.IsDark() && ! aDoubleColor.IsBright() )
759 : {
760 0 : aDoubleColor = Color( COL_WHITE );
761 0 : aSingleColor = Color( COL_BLACK );
762 : }
763 0 : else if( rBack.IsBright() && ! aDoubleColor.IsDark() )
764 : {
765 0 : aDoubleColor = Color( COL_BLACK );
766 0 : aSingleColor = Color( COL_WHITE );
767 : }
768 : }
769 : }
770 :
771 : // specify selection output
772 0 : WinBits nStyle = GetStyle();
773 0 : if ( nStyle & WB_MENUSTYLEVALUESET )
774 : {
775 0 : if ( bFocus )
776 0 : ShowFocus( aRect );
777 :
778 0 : if ( bDrawSel )
779 : {
780 0 : SetLineColor( mbBlackSel ? Color( COL_BLACK ) : aDoubleColor );
781 0 : DrawRect( aRect );
782 : }
783 : }
784 0 : else if ( nStyle & WB_RADIOSEL )
785 : {
786 0 : aRect.Left() += 3;
787 0 : aRect.Top() += 3;
788 0 : aRect.Right() -= 3;
789 0 : aRect.Bottom() -= 3;
790 0 : if ( nStyle & WB_DOUBLEBORDER )
791 : {
792 0 : aRect.Left()++;
793 0 : aRect.Top()++;
794 0 : aRect.Right()--;
795 0 : aRect.Bottom()--;
796 : }
797 :
798 0 : if ( bFocus )
799 0 : ShowFocus( aRect );
800 :
801 0 : aRect.Left()++;
802 0 : aRect.Top()++;
803 0 : aRect.Right()--;
804 0 : aRect.Bottom()--;
805 :
806 0 : if ( bDrawSel )
807 : {
808 0 : SetLineColor( aDoubleColor );
809 0 : aRect.Left()++;
810 0 : aRect.Top()++;
811 0 : aRect.Right()--;
812 0 : aRect.Bottom()--;
813 0 : DrawRect( aRect );
814 0 : aRect.Left()++;
815 0 : aRect.Top()++;
816 0 : aRect.Right()--;
817 0 : aRect.Bottom()--;
818 0 : DrawRect( aRect );
819 : }
820 : }
821 : else
822 : {
823 0 : if ( bDrawSel )
824 : {
825 0 : SetLineColor( mbBlackSel ? Color( COL_BLACK ) : aDoubleColor );
826 0 : DrawRect( aRect );
827 : }
828 0 : if ( mbDoubleSel )
829 : {
830 0 : aRect.Left()++;
831 0 : aRect.Top()++;
832 0 : aRect.Right()--;
833 0 : aRect.Bottom()--;
834 0 : if ( bDrawSel )
835 0 : DrawRect( aRect );
836 : }
837 0 : aRect.Left()++;
838 0 : aRect.Top()++;
839 0 : aRect.Right()--;
840 0 : aRect.Bottom()--;
841 0 : Rectangle aRect2 = aRect;
842 0 : aRect.Left()++;
843 0 : aRect.Top()++;
844 0 : aRect.Right()--;
845 0 : aRect.Bottom()--;
846 0 : if ( bDrawSel )
847 0 : DrawRect( aRect );
848 0 : if ( mbDoubleSel )
849 : {
850 0 : aRect.Left()++;
851 0 : aRect.Top()++;
852 0 : aRect.Right()--;
853 0 : aRect.Bottom()--;
854 0 : if ( bDrawSel )
855 0 : DrawRect( aRect );
856 : }
857 :
858 0 : if ( bDrawSel )
859 : {
860 0 : SetLineColor( mbBlackSel ? Color( COL_WHITE ) : aSingleColor );
861 : }
862 : else
863 : {
864 0 : SetLineColor( Color( COL_LIGHTGRAY ) );
865 : }
866 0 : DrawRect( aRect2 );
867 :
868 0 : if ( bFocus )
869 0 : ShowFocus( aRect2 );
870 : }
871 :
872 0 : ImplDrawItemText( pItem->maText );
873 : }
874 : }
875 :
876 : // -----------------------------------------------------------------------
877 :
878 0 : void ValueSet::ImplHideSelect( sal_uInt16 nItemId )
879 : {
880 0 : Rectangle aRect;
881 :
882 0 : const size_t nItemPos = GetItemPos( nItemId );
883 0 : if ( nItemPos != VALUESET_ITEM_NOTFOUND )
884 : {
885 0 : if ( !mItemList[nItemPos]->mbVisible )
886 : {
887 : return;
888 : }
889 0 : aRect = ImplGetItemRect(nItemPos);
890 : }
891 : else
892 : {
893 0 : if ( !mpNoneItem )
894 : {
895 : return;
896 : }
897 0 : aRect = maNoneItemRect;
898 : }
899 :
900 0 : HideFocus();
901 0 : const Point aPos = aRect.TopLeft();
902 0 : const Size aSize = aRect.GetSize();
903 0 : DrawOutDev( aPos, aSize, aPos, aSize, maVirDev );
904 : }
905 :
906 : // -----------------------------------------------------------------------
907 :
908 0 : void ValueSet::ImplHighlightItem( sal_uInt16 nItemId, bool bIsSelection )
909 : {
910 0 : if ( mnHighItemId != nItemId )
911 : {
912 : // remember the old item to delete the previous selection
913 0 : sal_uInt16 nOldItem = mnHighItemId;
914 0 : mnHighItemId = nItemId;
915 :
916 : // don't draw the selection if nothing is selected
917 0 : if ( !bIsSelection && mbNoSelection )
918 0 : mbDrawSelection = false;
919 :
920 : // remove the old selection and draw the new one
921 0 : ImplHideSelect( nOldItem );
922 0 : ImplDrawSelect();
923 0 : mbDrawSelection = true;
924 : }
925 0 : }
926 :
927 : // -----------------------------------------------------------------------
928 :
929 0 : void ValueSet::ImplDraw()
930 : {
931 0 : if ( mbFormat )
932 0 : Format();
933 :
934 0 : HideFocus();
935 :
936 0 : Point aDefPos;
937 0 : Size aSize = maVirDev.GetOutputSizePixel();
938 :
939 0 : if ( mpScrBar && mpScrBar->IsVisible() )
940 : {
941 0 : Point aScrPos = mpScrBar->GetPosPixel();
942 0 : Size aScrSize = mpScrBar->GetSizePixel();
943 0 : Point aTempPos( 0, aScrPos.Y() );
944 0 : Size aTempSize( aSize.Width(), aScrPos.Y() );
945 :
946 0 : DrawOutDev( aDefPos, aTempSize, aDefPos, aTempSize, maVirDev );
947 0 : aTempSize.Width() = aScrPos.X()-1;
948 0 : aTempSize.Height() = aScrSize.Height();
949 0 : DrawOutDev( aTempPos, aTempSize, aTempPos, aTempSize, maVirDev );
950 0 : aTempPos.Y() = aScrPos.Y()+aScrSize.Height();
951 0 : aTempSize.Width() = aSize.Width();
952 0 : aTempSize.Height() = aSize.Height()-aTempPos.Y();
953 0 : DrawOutDev( aTempPos, aTempSize, aTempPos, aTempSize, maVirDev );
954 : }
955 : else
956 0 : DrawOutDev( aDefPos, aSize, aDefPos, aSize, maVirDev );
957 :
958 : // draw parting line to the Namefield
959 0 : if ( GetStyle() & WB_NAMEFIELD )
960 : {
961 0 : if ( !(GetStyle() & WB_FLATVALUESET) )
962 : {
963 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
964 0 : Size aWinSize = GetOutputSizePixel();
965 0 : Point aPos1( NAME_LINE_OFF_X, mnTextOffset+NAME_LINE_OFF_Y );
966 0 : Point aPos2( aWinSize.Width()-(NAME_LINE_OFF_X*2), mnTextOffset+NAME_LINE_OFF_Y );
967 0 : if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) )
968 : {
969 0 : SetLineColor( rStyleSettings.GetShadowColor() );
970 0 : DrawLine( aPos1, aPos2 );
971 0 : aPos1.Y()++;
972 0 : aPos2.Y()++;
973 0 : SetLineColor( rStyleSettings.GetLightColor() );
974 : }
975 : else
976 0 : SetLineColor( rStyleSettings.GetWindowTextColor() );
977 0 : DrawLine( aPos1, aPos2 );
978 : }
979 : }
980 :
981 0 : ImplDrawSelect();
982 0 : }
983 :
984 : // -----------------------------------------------------------------------
985 :
986 0 : bool ValueSet::ImplScroll( const Point& rPos )
987 : {
988 0 : if ( !mbScroll || !maItemListRect.IsInside(rPos) )
989 0 : return false;
990 :
991 0 : const long nScrollOffset = (mnItemHeight <= 16) ? SCROLL_OFFSET/2 : SCROLL_OFFSET;
992 0 : bool bScroll = false;
993 :
994 0 : if ( rPos.Y() <= maItemListRect.Top()+nScrollOffset )
995 : {
996 0 : if ( mnFirstLine > 0 )
997 : {
998 0 : --mnFirstLine;
999 0 : bScroll = true;
1000 : }
1001 : }
1002 0 : else if ( rPos.Y() >= maItemListRect.Bottom()-nScrollOffset )
1003 : {
1004 0 : if ( mnFirstLine < static_cast<sal_uInt16>(mnLines-mnVisLines) )
1005 : {
1006 0 : ++mnFirstLine;
1007 0 : bScroll = true;
1008 : }
1009 : }
1010 :
1011 0 : if ( !bScroll )
1012 0 : return false;
1013 :
1014 0 : mbFormat = true;
1015 0 : ImplDraw();
1016 0 : return true;
1017 : }
1018 :
1019 : // -----------------------------------------------------------------------
1020 :
1021 0 : size_t ValueSet::ImplGetItem( const Point& rPos, bool bMove ) const
1022 : {
1023 0 : if ( !mbHasVisibleItems )
1024 : {
1025 0 : return VALUESET_ITEM_NOTFOUND;
1026 : }
1027 :
1028 0 : if ( mpNoneItem && maNoneItemRect.IsInside( rPos ) )
1029 : {
1030 0 : return VALUESET_ITEM_NONEITEM;
1031 : }
1032 :
1033 0 : if ( maItemListRect.IsInside( rPos ) )
1034 : {
1035 0 : const int xc = rPos.X()-maItemListRect.Left();
1036 0 : const int yc = rPos.Y()-maItemListRect.Top();
1037 : // The point is inside the area of item list,
1038 : // let's find the containing item.
1039 0 : const int col = xc/(mnItemWidth+mnSpacing);
1040 0 : const int x = xc%(mnItemWidth+mnSpacing);
1041 0 : const int row = yc/(mnItemHeight+mnSpacing);
1042 0 : const int y = yc%(mnItemHeight+mnSpacing);
1043 :
1044 0 : if (x<mnItemWidth && y<mnItemHeight)
1045 : {
1046 : // the point is inside item rect and not inside spacing
1047 0 : const size_t item = (mnFirstLine+row)*mnCols+col;
1048 0 : if (item < mItemList.size())
1049 : {
1050 0 : return item;
1051 : }
1052 : }
1053 :
1054 : // return the previously selected item if spacing is set and
1055 : // the mouse hasn't left the window yet
1056 0 : if ( bMove && mnSpacing && mnHighItemId )
1057 : {
1058 0 : return GetItemPos( mnHighItemId );
1059 : }
1060 : }
1061 :
1062 0 : return VALUESET_ITEM_NOTFOUND;
1063 : }
1064 :
1065 : // -----------------------------------------------------------------------
1066 :
1067 0 : ValueSetItem* ValueSet::ImplGetItem( size_t nPos )
1068 : {
1069 0 : if ( nPos == VALUESET_ITEM_NONEITEM )
1070 0 : return mpNoneItem;
1071 : else
1072 0 : return ( nPos < mItemList.size() ) ? mItemList[nPos] : NULL;
1073 : }
1074 :
1075 : // -----------------------------------------------------------------------
1076 :
1077 0 : ValueSetItem* ValueSet::ImplGetFirstItem()
1078 : {
1079 0 : return mItemList.size() ? mItemList[0] : NULL;
1080 : }
1081 :
1082 : // -----------------------------------------------------------------------
1083 :
1084 0 : sal_uInt16 ValueSet::ImplGetVisibleItemCount() const
1085 : {
1086 0 : sal_uInt16 nRet = 0;
1087 0 : const size_t nItemCount = mItemList.size();
1088 :
1089 0 : for ( size_t n = 0; n < nItemCount; ++n )
1090 : {
1091 0 : if ( mItemList[n]->mbVisible )
1092 0 : ++nRet;
1093 : }
1094 :
1095 0 : return nRet;
1096 : }
1097 :
1098 : // -----------------------------------------------------------------------
1099 :
1100 0 : ValueSetItem* ValueSet::ImplGetVisibleItem( sal_uInt16 nVisiblePos )
1101 : {
1102 0 : const size_t nItemCount = mItemList.size();
1103 :
1104 0 : for ( size_t n = 0; n < nItemCount; ++n )
1105 : {
1106 0 : ValueSetItem *const pItem = mItemList[n];
1107 :
1108 0 : if ( pItem->mbVisible && !nVisiblePos-- )
1109 0 : return pItem;
1110 : }
1111 :
1112 0 : return NULL;
1113 : }
1114 :
1115 : // -----------------------------------------------------------------------
1116 :
1117 0 : void ValueSet::ImplFireAccessibleEvent( short nEventId, const ::com::sun::star::uno::Any& rOldValue, const ::com::sun::star::uno::Any& rNewValue )
1118 : {
1119 0 : ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );
1120 :
1121 0 : if( pAcc )
1122 0 : pAcc->FireAccessibleEvent( nEventId, rOldValue, rNewValue );
1123 0 : }
1124 :
1125 : // -----------------------------------------------------------------------
1126 :
1127 0 : bool ValueSet::ImplHasAccessibleListeners()
1128 : {
1129 0 : ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );
1130 0 : return( pAcc && pAcc->HasAccessibleListeners() );
1131 : }
1132 :
1133 : // -----------------------------------------------------------------------
1134 :
1135 0 : IMPL_LINK( ValueSet,ImplScrollHdl, ScrollBar*, pScrollBar )
1136 : {
1137 0 : sal_uInt16 nNewFirstLine = (sal_uInt16)pScrollBar->GetThumbPos();
1138 0 : if ( nNewFirstLine != mnFirstLine )
1139 : {
1140 0 : mnFirstLine = nNewFirstLine;
1141 0 : mbFormat = true;
1142 0 : ImplDraw();
1143 : }
1144 0 : return 0;
1145 : }
1146 :
1147 : // -----------------------------------------------------------------------
1148 :
1149 0 : IMPL_LINK_NOARG(ValueSet, ImplTimerHdl)
1150 : {
1151 0 : ImplTracking( GetPointerPosPixel(), true );
1152 0 : return 0;
1153 : }
1154 :
1155 : // -----------------------------------------------------------------------
1156 :
1157 0 : void ValueSet::ImplTracking( const Point& rPos, bool bRepeat )
1158 : {
1159 0 : if ( bRepeat || mbSelection )
1160 : {
1161 0 : if ( ImplScroll( rPos ) )
1162 : {
1163 0 : if ( mbSelection )
1164 : {
1165 0 : maTimer.SetTimeoutHdl( LINK( this, ValueSet, ImplTimerHdl ) );
1166 0 : maTimer.SetTimeout( GetSettings().GetMouseSettings().GetScrollRepeat() );
1167 0 : maTimer.Start();
1168 : }
1169 : }
1170 : }
1171 :
1172 0 : ValueSetItem* pItem = ImplGetItem( ImplGetItem( rPos ) );
1173 0 : if ( pItem )
1174 : {
1175 0 : if( GetStyle() & WB_MENUSTYLEVALUESET )
1176 0 : mbHighlight = true;
1177 :
1178 0 : ImplHighlightItem( pItem->mnId );
1179 : }
1180 : else
1181 : {
1182 0 : if( GetStyle() & WB_MENUSTYLEVALUESET )
1183 0 : mbHighlight = true;
1184 :
1185 0 : ImplHighlightItem( mnSelItemId, false );
1186 : }
1187 0 : }
1188 :
1189 : // -----------------------------------------------------------------------
1190 :
1191 0 : void ValueSet::ImplEndTracking( const Point& rPos, bool bCancel )
1192 : {
1193 : ValueSetItem* pItem;
1194 :
1195 : // restore the old status in case of termination
1196 0 : if ( bCancel )
1197 0 : pItem = NULL;
1198 : else
1199 0 : pItem = ImplGetItem( ImplGetItem( rPos ) );
1200 :
1201 0 : if ( pItem )
1202 : {
1203 0 : SelectItem( pItem->mnId );
1204 0 : if ( !mbSelection && !(GetStyle() & WB_NOPOINTERFOCUS) )
1205 0 : GrabFocus();
1206 0 : mbHighlight = false;
1207 0 : mbSelection = false;
1208 0 : Select();
1209 : }
1210 : else
1211 : {
1212 0 : ImplHighlightItem( mnSelItemId, false );
1213 0 : mbHighlight = false;
1214 0 : mbSelection = false;
1215 : }
1216 0 : }
1217 :
1218 : // -----------------------------------------------------------------------
1219 :
1220 0 : void ValueSet::MouseButtonDown( const MouseEvent& rMEvt )
1221 : {
1222 0 : if ( rMEvt.IsLeft() )
1223 : {
1224 0 : ValueSetItem* pItem = ImplGetItem( ImplGetItem( rMEvt.GetPosPixel() ) );
1225 0 : if ( mbSelection )
1226 : {
1227 0 : mbHighlight = true;
1228 0 : if ( pItem )
1229 : {
1230 0 : mnHighItemId = mnSelItemId;
1231 0 : ImplHighlightItem( pItem->mnId );
1232 : }
1233 :
1234 0 : return;
1235 : }
1236 : else
1237 : {
1238 0 : if ( pItem && !rMEvt.IsMod2() )
1239 : {
1240 0 : if ( rMEvt.GetClicks() == 1 )
1241 : {
1242 0 : mbHighlight = true;
1243 0 : mnHighItemId = mnSelItemId;
1244 0 : ImplHighlightItem( pItem->mnId );
1245 0 : StartTracking( STARTTRACK_SCROLLREPEAT );
1246 : }
1247 0 : else if ( rMEvt.GetClicks() == 2 )
1248 0 : DoubleClick();
1249 :
1250 0 : return;
1251 : }
1252 : }
1253 : }
1254 :
1255 0 : Control::MouseButtonDown( rMEvt );
1256 : }
1257 :
1258 : // -----------------------------------------------------------------------
1259 :
1260 0 : void ValueSet::MouseButtonUp( const MouseEvent& rMEvt )
1261 : {
1262 : // because of SelectionMode
1263 0 : if ( rMEvt.IsLeft() && mbSelection )
1264 0 : ImplEndTracking( rMEvt.GetPosPixel(), false );
1265 : else
1266 0 : Control::MouseButtonUp( rMEvt );
1267 0 : }
1268 :
1269 : // -----------------------------------------------------------------------
1270 :
1271 0 : void ValueSet::MouseMove( const MouseEvent& rMEvt )
1272 : {
1273 : // because of SelectionMode
1274 0 : if ( mbSelection || (GetStyle() & WB_MENUSTYLEVALUESET) )
1275 0 : ImplTracking( rMEvt.GetPosPixel(), false );
1276 0 : Control::MouseMove( rMEvt );
1277 0 : }
1278 :
1279 : // -----------------------------------------------------------------------
1280 :
1281 0 : void ValueSet::Tracking( const TrackingEvent& rTEvt )
1282 : {
1283 0 : Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
1284 :
1285 0 : if ( rTEvt.IsTrackingEnded() )
1286 0 : ImplEndTracking( aMousePos, rTEvt.IsTrackingCanceled() );
1287 : else
1288 0 : ImplTracking( aMousePos, rTEvt.IsTrackingRepeat() );
1289 0 : }
1290 :
1291 : // -----------------------------------------------------------------------
1292 :
1293 0 : void ValueSet::KeyInput( const KeyEvent& rKEvt )
1294 : {
1295 0 : size_t nLastItem = mItemList.size();
1296 :
1297 0 : if ( !nLastItem || !ImplGetFirstItem() )
1298 : {
1299 0 : Control::KeyInput( rKEvt );
1300 0 : return;
1301 : }
1302 :
1303 0 : --nLastItem;
1304 0 : const size_t nCurPos = mnSelItemId ? GetItemPos( mnSelItemId )
1305 0 : : mpNoneItem ? VALUESET_ITEM_NONEITEM : 0;
1306 0 : size_t nItemPos = VALUESET_ITEM_NOTFOUND;
1307 0 : size_t nVStep = mnCols;
1308 :
1309 0 : switch ( rKEvt.GetKeyCode().GetCode() )
1310 : {
1311 : case KEY_HOME:
1312 0 : nItemPos = mpNoneItem ? VALUESET_ITEM_NONEITEM : 0;
1313 0 : break;
1314 :
1315 : case KEY_END:
1316 0 : nItemPos = nLastItem;
1317 0 : break;
1318 :
1319 : case KEY_LEFT:
1320 0 : if (nCurPos != VALUESET_ITEM_NONEITEM)
1321 : {
1322 0 : if (nCurPos)
1323 : {
1324 0 : nItemPos = nCurPos-1;
1325 : }
1326 0 : else if (mpNoneItem)
1327 : {
1328 0 : nItemPos = VALUESET_ITEM_NONEITEM;
1329 : }
1330 : }
1331 0 : break;
1332 :
1333 : case KEY_RIGHT:
1334 0 : if (nCurPos < nLastItem)
1335 : {
1336 0 : if (nCurPos == VALUESET_ITEM_NONEITEM)
1337 : {
1338 0 : nItemPos = 0;
1339 : }
1340 : else
1341 : {
1342 0 : nItemPos = nCurPos+1;
1343 : }
1344 : }
1345 0 : break;
1346 :
1347 : case KEY_PAGEUP:
1348 0 : if (rKEvt.GetKeyCode().IsShift() || rKEvt.GetKeyCode().IsMod1() || rKEvt.GetKeyCode().IsMod2())
1349 : {
1350 0 : Control::KeyInput( rKEvt );
1351 0 : return;
1352 : }
1353 0 : nVStep *= mnVisLines;
1354 : // intentional fall-through
1355 : case KEY_UP:
1356 0 : if (nCurPos != VALUESET_ITEM_NONEITEM)
1357 : {
1358 0 : if (nCurPos == nLastItem)
1359 : {
1360 0 : const size_t nCol = nLastItem % mnCols;
1361 0 : if (nCol < mnCurCol)
1362 : {
1363 : // Move to previous row/page, keeping the old column
1364 0 : nVStep -= mnCurCol - nCol;
1365 : }
1366 : }
1367 0 : if (nCurPos >= nVStep)
1368 : {
1369 : // Go up of a whole page
1370 0 : nItemPos = nCurPos-nVStep;
1371 : }
1372 0 : else if (mpNoneItem)
1373 : {
1374 0 : nItemPos = VALUESET_ITEM_NONEITEM;
1375 : }
1376 0 : else if (nCurPos > mnCols)
1377 : {
1378 : // Go to same column in first row
1379 0 : nItemPos = nCurPos % mnCols;
1380 : }
1381 : }
1382 0 : break;
1383 :
1384 : case KEY_PAGEDOWN:
1385 0 : if (rKEvt.GetKeyCode().IsShift() || rKEvt.GetKeyCode().IsMod1() || rKEvt.GetKeyCode().IsMod2())
1386 : {
1387 0 : Control::KeyInput( rKEvt );
1388 0 : return;
1389 : }
1390 0 : nVStep *= mnVisLines;
1391 : // intentional fall-through
1392 : case KEY_DOWN:
1393 0 : if (nCurPos != nLastItem)
1394 : {
1395 0 : if (nCurPos == VALUESET_ITEM_NONEITEM)
1396 : {
1397 0 : nItemPos = nVStep-mnCols+mnCurCol;
1398 : }
1399 : else
1400 : {
1401 0 : nItemPos = nCurPos+nVStep;
1402 : }
1403 0 : if (nItemPos > nLastItem)
1404 : {
1405 0 : nItemPos = nLastItem;
1406 : }
1407 : }
1408 0 : break;
1409 :
1410 : case KEY_RETURN:
1411 0 : if (GetStyle() & WB_NO_DIRECTSELECT)
1412 : {
1413 0 : Select();
1414 0 : break;
1415 : }
1416 : // intentional fall-through
1417 : default:
1418 0 : Control::KeyInput( rKEvt );
1419 0 : return;
1420 : }
1421 :
1422 : // This point is reached only if key travelling was used,
1423 : // in which case selection mode should be switched off
1424 0 : EndSelection();
1425 :
1426 0 : if ( nItemPos != VALUESET_ITEM_NOTFOUND )
1427 : {
1428 0 : if ( nItemPos!=VALUESET_ITEM_NONEITEM && nItemPos<nLastItem )
1429 : {
1430 : // update current column only in case of a new position
1431 : // which is also not a "specially" handled one.
1432 0 : mnCurCol = nItemPos % mnCols;
1433 : }
1434 0 : const sal_uInt16 nItemId = (nItemPos != VALUESET_ITEM_NONEITEM) ? GetItemId( nItemPos ) : 0;
1435 0 : if ( nItemId != mnSelItemId )
1436 : {
1437 0 : SelectItem( nItemId );
1438 0 : if (!(GetStyle() & WB_NO_DIRECTSELECT))
1439 : {
1440 : // select only if WB_NO_DIRECTSELECT is not set
1441 0 : Select();
1442 : }
1443 : }
1444 : }
1445 : }
1446 :
1447 : // -----------------------------------------------------------------------
1448 :
1449 0 : void ValueSet::Command( const CommandEvent& rCEvt )
1450 : {
1451 0 : if ( (rCEvt.GetCommand() == COMMAND_WHEEL) ||
1452 0 : (rCEvt.GetCommand() == COMMAND_STARTAUTOSCROLL) ||
1453 0 : (rCEvt.GetCommand() == COMMAND_AUTOSCROLL) )
1454 : {
1455 0 : if ( HandleScrollCommand( rCEvt, NULL, mpScrBar ) )
1456 0 : return;
1457 : }
1458 :
1459 0 : Control::Command( rCEvt );
1460 : }
1461 :
1462 : // -----------------------------------------------------------------------
1463 :
1464 0 : void ValueSet::Paint( const Rectangle& )
1465 : {
1466 0 : if ( GetStyle() & WB_FLATVALUESET )
1467 : {
1468 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1469 0 : SetLineColor();
1470 0 : SetFillColor( rStyleSettings.GetFaceColor() );
1471 0 : long nOffY = maVirDev.GetOutputSizePixel().Height();
1472 0 : Size aWinSize = GetOutputSizePixel();
1473 0 : DrawRect( Rectangle( Point( 0, nOffY ), Point( aWinSize.Width(), aWinSize.Height() ) ) );
1474 : }
1475 :
1476 0 : ImplDraw();
1477 0 : }
1478 :
1479 : // -----------------------------------------------------------------------
1480 :
1481 0 : void ValueSet::GetFocus()
1482 : {
1483 : OSL_TRACE ("value set getting focus");
1484 0 : ImplDrawSelect();
1485 0 : Control::GetFocus();
1486 :
1487 : // Tell the accessible object that we got the focus.
1488 0 : ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );
1489 0 : if( pAcc )
1490 0 : pAcc->GetFocus();
1491 0 : }
1492 :
1493 : // -----------------------------------------------------------------------
1494 :
1495 0 : void ValueSet::LoseFocus()
1496 : {
1497 : OSL_TRACE ("value set losing focus");
1498 0 : if ( mbNoSelection && mnSelItemId )
1499 0 : ImplHideSelect( mnSelItemId );
1500 : else
1501 0 : HideFocus();
1502 0 : Control::LoseFocus();
1503 :
1504 : // Tell the accessible object that we lost the focus.
1505 0 : ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );
1506 0 : if( pAcc )
1507 0 : pAcc->LoseFocus();
1508 0 : }
1509 :
1510 : // -----------------------------------------------------------------------
1511 :
1512 0 : void ValueSet::Resize()
1513 : {
1514 0 : mbFormat = true;
1515 0 : if ( IsReallyVisible() && IsUpdateMode() )
1516 0 : Invalidate();
1517 0 : Control::Resize();
1518 0 : }
1519 :
1520 : // -----------------------------------------------------------------------
1521 :
1522 0 : void ValueSet::RequestHelp( const HelpEvent& rHEvt )
1523 : {
1524 0 : if ( (rHEvt.GetMode() & (HELPMODE_QUICK | HELPMODE_BALLOON)) == HELPMODE_QUICK )
1525 : {
1526 0 : Point aPos = ScreenToOutputPixel( rHEvt.GetMousePosPixel() );
1527 0 : size_t nItemPos = ImplGetItem( aPos );
1528 0 : if ( nItemPos != VALUESET_ITEM_NOTFOUND )
1529 : {
1530 0 : Rectangle aItemRect = ImplGetItemRect( nItemPos );
1531 0 : Point aPt = OutputToScreenPixel( aItemRect.TopLeft() );
1532 0 : aItemRect.Left() = aPt.X();
1533 0 : aItemRect.Top() = aPt.Y();
1534 0 : aPt = OutputToScreenPixel( aItemRect.BottomRight() );
1535 0 : aItemRect.Right() = aPt.X();
1536 0 : aItemRect.Bottom() = aPt.Y();
1537 0 : Help::ShowQuickHelp( this, aItemRect, GetItemText( ImplGetItem( nItemPos )->mnId ) );
1538 0 : return;
1539 : }
1540 : }
1541 :
1542 0 : Control::RequestHelp( rHEvt );
1543 : }
1544 :
1545 : // -----------------------------------------------------------------------
1546 :
1547 0 : void ValueSet::StateChanged( StateChangedType nType )
1548 : {
1549 0 : Control::StateChanged( nType );
1550 :
1551 0 : if ( nType == STATE_CHANGE_INITSHOW )
1552 : {
1553 0 : if ( mbFormat )
1554 0 : Format();
1555 : }
1556 0 : else if ( nType == STATE_CHANGE_UPDATEMODE )
1557 : {
1558 0 : if ( IsReallyVisible() && IsUpdateMode() )
1559 0 : Invalidate();
1560 : }
1561 0 : else if ( nType == STATE_CHANGE_TEXT )
1562 : {
1563 0 : if ( mpNoneItem && !mbFormat && IsReallyVisible() && IsUpdateMode() )
1564 : {
1565 0 : ImplFormatItem( mpNoneItem, maNoneItemRect );
1566 0 : Invalidate( maNoneItemRect );
1567 : }
1568 : }
1569 0 : else if ( (nType == STATE_CHANGE_ZOOM) ||
1570 : (nType == STATE_CHANGE_CONTROLFONT) )
1571 : {
1572 0 : ImplInitSettings( true, false, false );
1573 0 : Invalidate();
1574 : }
1575 0 : else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
1576 : {
1577 0 : ImplInitSettings( false, true, false );
1578 0 : Invalidate();
1579 : }
1580 0 : else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
1581 : {
1582 0 : ImplInitSettings( false, false, true );
1583 0 : Invalidate();
1584 : }
1585 0 : else if ( (nType == STATE_CHANGE_STYLE) || (nType == STATE_CHANGE_ENABLE) )
1586 : {
1587 0 : mbFormat = true;
1588 0 : ImplInitSettings( false, false, true );
1589 0 : Invalidate();
1590 : }
1591 0 : }
1592 :
1593 : // -----------------------------------------------------------------------
1594 :
1595 0 : void ValueSet::DataChanged( const DataChangedEvent& rDCEvt )
1596 : {
1597 0 : Control::DataChanged( rDCEvt );
1598 :
1599 0 : if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
1600 0 : (rDCEvt.GetType() == DATACHANGED_DISPLAY) ||
1601 0 : (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
1602 0 : ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1603 0 : (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
1604 : {
1605 0 : mbFormat = true;
1606 0 : ImplInitSettings( true, true, true );
1607 0 : Invalidate();
1608 : }
1609 0 : }
1610 :
1611 : // -----------------------------------------------------------------------
1612 :
1613 0 : void ValueSet::Select()
1614 : {
1615 0 : maSelectHdl.Call( this );
1616 0 : }
1617 :
1618 : // -----------------------------------------------------------------------
1619 :
1620 0 : void ValueSet::DoubleClick()
1621 : {
1622 0 : maDoubleClickHdl.Call( this );
1623 0 : }
1624 :
1625 : // -----------------------------------------------------------------------
1626 :
1627 0 : void ValueSet::UserDraw( const UserDrawEvent& )
1628 : {
1629 0 : }
1630 :
1631 : // -----------------------------------------------------------------------
1632 :
1633 0 : void ValueSet::InsertItem( sal_uInt16 nItemId, const Image& rImage, size_t nPos )
1634 : {
1635 0 : ValueSetItem* pItem = new ValueSetItem( *this );
1636 0 : pItem->mnId = nItemId;
1637 0 : pItem->meType = VALUESETITEM_IMAGE;
1638 0 : pItem->maImage = rImage;
1639 0 : ImplInsertItem( pItem, nPos );
1640 0 : }
1641 :
1642 : // -----------------------------------------------------------------------
1643 :
1644 0 : void ValueSet::InsertItem( sal_uInt16 nItemId, const Color& rColor, size_t nPos )
1645 : {
1646 0 : ValueSetItem* pItem = new ValueSetItem( *this );
1647 0 : pItem->mnId = nItemId;
1648 0 : pItem->meType = VALUESETITEM_COLOR;
1649 0 : pItem->maColor = rColor;
1650 0 : ImplInsertItem( pItem, nPos );
1651 0 : }
1652 :
1653 : // -----------------------------------------------------------------------
1654 :
1655 0 : void ValueSet::InsertItem( sal_uInt16 nItemId, const Image& rImage,
1656 : const XubString& rText, size_t nPos )
1657 : {
1658 0 : ValueSetItem* pItem = new ValueSetItem( *this );
1659 0 : pItem->mnId = nItemId;
1660 0 : pItem->meType = VALUESETITEM_IMAGE;
1661 0 : pItem->maImage = rImage;
1662 0 : pItem->maText = rText;
1663 0 : ImplInsertItem( pItem, nPos );
1664 0 : }
1665 :
1666 : // -----------------------------------------------------------------------
1667 :
1668 0 : void ValueSet::InsertItem( sal_uInt16 nItemId, const Color& rColor,
1669 : const XubString& rText, size_t nPos )
1670 : {
1671 0 : ValueSetItem* pItem = new ValueSetItem( *this );
1672 0 : pItem->mnId = nItemId;
1673 0 : pItem->meType = VALUESETITEM_COLOR;
1674 0 : pItem->maColor = rColor;
1675 0 : pItem->maText = rText;
1676 0 : ImplInsertItem( pItem, nPos );
1677 0 : }
1678 :
1679 : // -----------------------------------------------------------------------
1680 :
1681 0 : void ValueSet::InsertItem( sal_uInt16 nItemId, size_t nPos )
1682 : {
1683 0 : ValueSetItem* pItem = new ValueSetItem( *this );
1684 0 : pItem->mnId = nItemId;
1685 0 : pItem->meType = VALUESETITEM_USERDRAW;
1686 0 : ImplInsertItem( pItem, nPos );
1687 0 : }
1688 :
1689 : // -----------------------------------------------------------------------
1690 :
1691 0 : void ValueSet::ImplInsertItem( ValueSetItem *const pItem, const size_t nPos )
1692 : {
1693 : DBG_ASSERT( pItem->mnId, "ValueSet::InsertItem(): ItemId == 0" );
1694 : DBG_ASSERT( GetItemPos( pItem->mnId ) == VALUESET_ITEM_NOTFOUND,
1695 : "ValueSet::InsertItem(): ItemId already exists" );
1696 :
1697 0 : if ( nPos < mItemList.size() ) {
1698 0 : ValueItemList::iterator it = mItemList.begin();
1699 0 : ::std::advance( it, nPos );
1700 0 : mItemList.insert( it, pItem );
1701 : } else {
1702 0 : mItemList.push_back( pItem );
1703 : }
1704 :
1705 0 : mbFormat = true;
1706 0 : if ( IsReallyVisible() && IsUpdateMode() )
1707 0 : Invalidate();
1708 0 : }
1709 :
1710 : // -----------------------------------------------------------------------
1711 :
1712 0 : Rectangle ValueSet::ImplGetItemRect( size_t nPos ) const
1713 : {
1714 0 : const size_t nVisibleBegin = static_cast<size_t>(mnFirstLine)*mnCols;
1715 0 : const size_t nVisibleEnd = nVisibleBegin + static_cast<size_t>(mnVisLines)*mnCols;
1716 :
1717 : // Check if the item is inside the range of the displayed ones,
1718 : // taking into account that last row could be incomplete
1719 0 : if ( nPos<nVisibleBegin || nPos>=nVisibleEnd || nPos>=mItemList.size() )
1720 0 : return Rectangle();
1721 :
1722 0 : nPos -= nVisibleBegin;
1723 :
1724 0 : const size_t row = nPos/mnCols;
1725 0 : const size_t col = nPos%mnCols;
1726 0 : const long x = maItemListRect.Left()+col*(mnItemWidth+mnSpacing);
1727 0 : const long y = maItemListRect.Top()+row*(mnItemHeight+mnSpacing);
1728 :
1729 0 : return Rectangle( Point(x, y), Size(mnItemWidth, mnItemHeight) );
1730 : }
1731 :
1732 : // -----------------------------------------------------------------------
1733 :
1734 0 : void ValueSet::RemoveItem( sal_uInt16 nItemId )
1735 : {
1736 0 : size_t nPos = GetItemPos( nItemId );
1737 :
1738 0 : if ( nPos == VALUESET_ITEM_NOTFOUND )
1739 0 : return;
1740 :
1741 0 : if ( nPos < mItemList.size() ) {
1742 0 : ValueItemList::iterator it = mItemList.begin();
1743 0 : ::std::advance( it, nPos );
1744 0 : delete *it;
1745 0 : mItemList.erase( it );
1746 : }
1747 :
1748 : // reset variables
1749 0 : if ( (mnHighItemId == nItemId) || (mnSelItemId == nItemId) )
1750 : {
1751 0 : mnCurCol = 0;
1752 0 : mnHighItemId = 0;
1753 0 : mnSelItemId = 0;
1754 0 : mbNoSelection = true;
1755 : }
1756 :
1757 0 : mbFormat = true;
1758 0 : if ( IsReallyVisible() && IsUpdateMode() )
1759 0 : Invalidate();
1760 : }
1761 :
1762 : // -----------------------------------------------------------------------
1763 :
1764 0 : void ValueSet::Clear()
1765 : {
1766 0 : ImplDeleteItems();
1767 :
1768 : // reset variables
1769 0 : mnFirstLine = 0;
1770 0 : mnCurCol = 0;
1771 0 : mnHighItemId = 0;
1772 0 : mnSelItemId = 0;
1773 0 : mbNoSelection = true;
1774 :
1775 0 : mbFormat = true;
1776 0 : if ( IsReallyVisible() && IsUpdateMode() )
1777 0 : Invalidate();
1778 0 : }
1779 :
1780 : // -----------------------------------------------------------------------
1781 :
1782 0 : size_t ValueSet::GetItemCount() const
1783 : {
1784 0 : return mItemList.size();
1785 : }
1786 :
1787 : // -----------------------------------------------------------------------
1788 :
1789 0 : size_t ValueSet::GetItemPos( sal_uInt16 nItemId ) const
1790 : {
1791 0 : for ( size_t i = 0, n = mItemList.size(); i < n; ++i ) {
1792 0 : if ( mItemList[i]->mnId == nItemId ) {
1793 0 : return i;
1794 : }
1795 : }
1796 0 : return VALUESET_ITEM_NOTFOUND;
1797 : }
1798 :
1799 : // -----------------------------------------------------------------------
1800 :
1801 0 : sal_uInt16 ValueSet::GetItemId( size_t nPos ) const
1802 : {
1803 0 : return ( nPos < mItemList.size() ) ? mItemList[nPos]->mnId : 0 ;
1804 : }
1805 :
1806 : // -----------------------------------------------------------------------
1807 :
1808 0 : sal_uInt16 ValueSet::GetItemId( const Point& rPos ) const
1809 : {
1810 0 : size_t nItemPos = ImplGetItem( rPos );
1811 0 : if ( nItemPos != VALUESET_ITEM_NOTFOUND )
1812 0 : return GetItemId( nItemPos );
1813 :
1814 0 : return 0;
1815 : }
1816 :
1817 : // -----------------------------------------------------------------------
1818 :
1819 0 : Rectangle ValueSet::GetItemRect( sal_uInt16 nItemId ) const
1820 : {
1821 0 : const size_t nPos = GetItemPos( nItemId );
1822 :
1823 0 : if ( nPos!=VALUESET_ITEM_NOTFOUND && mItemList[nPos]->mbVisible )
1824 0 : return ImplGetItemRect( nPos );
1825 :
1826 0 : return Rectangle();
1827 : }
1828 :
1829 : // -----------------------------------------------------------------------
1830 :
1831 0 : void ValueSet::EnableFullItemMode( bool bFullMode )
1832 : {
1833 0 : mbFullMode = bFullMode;
1834 0 : }
1835 :
1836 : // -----------------------------------------------------------------------
1837 :
1838 0 : void ValueSet::SetColCount( sal_uInt16 nNewCols )
1839 : {
1840 0 : if ( mnUserCols != nNewCols )
1841 : {
1842 0 : mnUserCols = nNewCols;
1843 0 : mbFormat = true;
1844 0 : if ( IsReallyVisible() && IsUpdateMode() )
1845 0 : Invalidate();
1846 : }
1847 0 : }
1848 :
1849 : // -----------------------------------------------------------------------
1850 :
1851 0 : void ValueSet::SetLineCount( sal_uInt16 nNewLines )
1852 : {
1853 0 : if ( mnUserVisLines != nNewLines )
1854 : {
1855 0 : mnUserVisLines = nNewLines;
1856 0 : mbFormat = true;
1857 0 : if ( IsReallyVisible() && IsUpdateMode() )
1858 0 : Invalidate();
1859 : }
1860 0 : }
1861 :
1862 : // -----------------------------------------------------------------------
1863 :
1864 0 : void ValueSet::SetItemWidth( long nNewItemWidth )
1865 : {
1866 0 : if ( mnUserItemWidth != nNewItemWidth )
1867 : {
1868 0 : mnUserItemWidth = nNewItemWidth;
1869 0 : mbFormat = true;
1870 0 : if ( IsReallyVisible() && IsUpdateMode() )
1871 0 : Invalidate();
1872 : }
1873 0 : }
1874 :
1875 : // -----------------------------------------------------------------------
1876 :
1877 0 : void ValueSet::SetItemHeight( long nNewItemHeight )
1878 : {
1879 0 : if ( mnUserItemHeight != nNewItemHeight )
1880 : {
1881 0 : mnUserItemHeight = nNewItemHeight;
1882 0 : mbFormat = true;
1883 0 : if ( IsReallyVisible() && IsUpdateMode() )
1884 0 : Invalidate();
1885 : }
1886 0 : }
1887 :
1888 : // -----------------------------------------------------------------------
1889 :
1890 0 : void ValueSet::SelectItem( sal_uInt16 nItemId )
1891 : {
1892 0 : size_t nItemPos = 0;
1893 :
1894 0 : if ( nItemId )
1895 : {
1896 0 : nItemPos = GetItemPos( nItemId );
1897 0 : if ( nItemPos == VALUESET_ITEM_NOTFOUND )
1898 0 : return;
1899 : }
1900 :
1901 0 : if ( (mnSelItemId != nItemId) || mbNoSelection )
1902 : {
1903 0 : sal_uInt16 nOldItem = mnSelItemId ? mnSelItemId : 1;
1904 0 : mnSelItemId = nItemId;
1905 0 : mbNoSelection = false;
1906 :
1907 0 : bool bNewOut = !mbFormat && IsReallyVisible() && IsUpdateMode();
1908 0 : bool bNewLine = false;
1909 :
1910 : // if necessary scroll to the visible area
1911 0 : if ( mbScroll && nItemId )
1912 : {
1913 0 : sal_uInt16 nNewLine = (sal_uInt16)(nItemPos / mnCols);
1914 0 : if ( nNewLine < mnFirstLine )
1915 : {
1916 0 : mnFirstLine = nNewLine;
1917 0 : bNewLine = true;
1918 : }
1919 0 : else if ( nNewLine > (sal_uInt16)(mnFirstLine+mnVisLines-1) )
1920 : {
1921 0 : mnFirstLine = (sal_uInt16)(nNewLine-mnVisLines+1);
1922 0 : bNewLine = true;
1923 : }
1924 : }
1925 :
1926 0 : if ( bNewOut )
1927 : {
1928 0 : if ( bNewLine )
1929 : {
1930 : // redraw everything if the visible area has changed
1931 0 : mbFormat = true;
1932 0 : ImplDraw();
1933 : }
1934 : else
1935 : {
1936 : // remove old selection and draw the new one
1937 0 : ImplHideSelect( nOldItem );
1938 0 : ImplDrawSelect();
1939 : }
1940 : }
1941 :
1942 0 : if( ImplHasAccessibleListeners() )
1943 : {
1944 : // focus event (deselect)
1945 0 : if( nOldItem )
1946 : {
1947 0 : const size_t nPos = GetItemPos( nItemId );
1948 :
1949 0 : if( nPos != VALUESET_ITEM_NOTFOUND )
1950 : {
1951 : ValueItemAcc* pItemAcc = ValueItemAcc::getImplementation(
1952 0 : mItemList[nPos]->GetAccessible( mbIsTransientChildrenDisabled ) );
1953 :
1954 0 : if( pItemAcc )
1955 : {
1956 0 : ::com::sun::star::uno::Any aOldAny, aNewAny;
1957 0 : if( !mbIsTransientChildrenDisabled )
1958 : {
1959 : aOldAny <<= ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >(
1960 0 : static_cast< ::cppu::OWeakObject* >( pItemAcc ));
1961 0 : ImplFireAccessibleEvent (::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldAny, aNewAny );
1962 : }
1963 : else
1964 : {
1965 0 : aOldAny <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED;
1966 0 : pItemAcc->FireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );
1967 0 : }
1968 : }
1969 : }
1970 : }
1971 :
1972 : // focus event (select)
1973 0 : const size_t nPos = GetItemPos( mnSelItemId );
1974 :
1975 : ValueSetItem* pItem;
1976 0 : if( nPos != VALUESET_ITEM_NOTFOUND )
1977 0 : pItem = mItemList[nPos];
1978 : else
1979 0 : pItem = mpNoneItem;
1980 :
1981 0 : ValueItemAcc* pItemAcc = NULL;
1982 0 : if (pItem != NULL)
1983 0 : pItemAcc = ValueItemAcc::getImplementation( pItem->GetAccessible( mbIsTransientChildrenDisabled ) );
1984 :
1985 0 : if( pItemAcc )
1986 : {
1987 0 : ::com::sun::star::uno::Any aOldAny, aNewAny;
1988 0 : if( !mbIsTransientChildrenDisabled )
1989 : {
1990 : aNewAny <<= ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >(
1991 0 : static_cast< ::cppu::OWeakObject* >( pItemAcc ));
1992 0 : ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldAny, aNewAny );
1993 : }
1994 : else
1995 : {
1996 0 : aNewAny <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED;
1997 0 : pItemAcc->FireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );
1998 0 : }
1999 : }
2000 :
2001 : // selection event
2002 0 : ::com::sun::star::uno::Any aOldAny, aNewAny;
2003 0 : ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::SELECTION_CHANGED, aOldAny, aNewAny );
2004 : }
2005 0 : maHighlightHdl.Call(this);
2006 : }
2007 : }
2008 :
2009 : // -----------------------------------------------------------------------
2010 :
2011 0 : void ValueSet::SetNoSelection()
2012 : {
2013 0 : mbNoSelection = true;
2014 0 : mbHighlight = false;
2015 0 : mbSelection = false;
2016 :
2017 0 : if ( IsReallyVisible() && IsUpdateMode() )
2018 0 : ImplDraw();
2019 0 : }
2020 :
2021 : // -----------------------------------------------------------------------
2022 :
2023 0 : void ValueSet::SetItemImage( sal_uInt16 nItemId, const Image& rImage )
2024 : {
2025 0 : size_t nPos = GetItemPos( nItemId );
2026 :
2027 0 : if ( nPos == VALUESET_ITEM_NOTFOUND )
2028 0 : return;
2029 :
2030 0 : ValueSetItem* pItem = mItemList[nPos];
2031 0 : pItem->meType = VALUESETITEM_IMAGE;
2032 0 : pItem->maImage = rImage;
2033 :
2034 0 : if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
2035 : {
2036 0 : const Rectangle aRect = ImplGetItemRect(nPos);
2037 0 : ImplFormatItem( pItem, aRect );
2038 0 : Invalidate( aRect );
2039 : }
2040 : else
2041 0 : mbFormat = true;
2042 : }
2043 :
2044 : // -----------------------------------------------------------------------
2045 :
2046 0 : Image ValueSet::GetItemImage( sal_uInt16 nItemId ) const
2047 : {
2048 0 : size_t nPos = GetItemPos( nItemId );
2049 :
2050 0 : if ( nPos != VALUESET_ITEM_NOTFOUND )
2051 0 : return mItemList[nPos]->maImage;
2052 : else
2053 0 : return Image();
2054 : }
2055 :
2056 : // -----------------------------------------------------------------------
2057 :
2058 0 : void ValueSet::SetItemColor( sal_uInt16 nItemId, const Color& rColor )
2059 : {
2060 0 : size_t nPos = GetItemPos( nItemId );
2061 :
2062 0 : if ( nPos == VALUESET_ITEM_NOTFOUND )
2063 0 : return;
2064 :
2065 0 : ValueSetItem* pItem = mItemList[nPos];
2066 0 : pItem->meType = VALUESETITEM_COLOR;
2067 0 : pItem->maColor = rColor;
2068 :
2069 0 : if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
2070 : {
2071 0 : const Rectangle aRect = ImplGetItemRect(nPos);
2072 0 : ImplFormatItem( pItem, aRect );
2073 0 : Invalidate( aRect );
2074 : }
2075 : else
2076 0 : mbFormat = true;
2077 : }
2078 :
2079 : // -----------------------------------------------------------------------
2080 :
2081 0 : Color ValueSet::GetItemColor( sal_uInt16 nItemId ) const
2082 : {
2083 0 : size_t nPos = GetItemPos( nItemId );
2084 :
2085 0 : if ( nPos != VALUESET_ITEM_NOTFOUND )
2086 0 : return mItemList[nPos]->maColor;
2087 : else
2088 0 : return Color();
2089 : }
2090 :
2091 : // -----------------------------------------------------------------------
2092 :
2093 0 : void ValueSet::SetItemData( sal_uInt16 nItemId, void* pData )
2094 : {
2095 0 : size_t nPos = GetItemPos( nItemId );
2096 :
2097 0 : if ( nPos == VALUESET_ITEM_NOTFOUND )
2098 0 : return;
2099 :
2100 0 : ValueSetItem* pItem = mItemList[nPos];
2101 0 : pItem->mpData = pData;
2102 :
2103 0 : if ( pItem->meType == VALUESETITEM_USERDRAW )
2104 : {
2105 0 : if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
2106 : {
2107 0 : const Rectangle aRect = ImplGetItemRect(nPos);
2108 0 : ImplFormatItem( pItem, aRect );
2109 0 : Invalidate( aRect );
2110 : }
2111 : else
2112 0 : mbFormat = true;
2113 : }
2114 : }
2115 :
2116 : // -----------------------------------------------------------------------
2117 :
2118 0 : void* ValueSet::GetItemData( sal_uInt16 nItemId ) const
2119 : {
2120 0 : size_t nPos = GetItemPos( nItemId );
2121 :
2122 0 : if ( nPos != VALUESET_ITEM_NOTFOUND )
2123 0 : return mItemList[nPos]->mpData;
2124 : else
2125 0 : return NULL;
2126 : }
2127 :
2128 : // -----------------------------------------------------------------------
2129 :
2130 0 : void ValueSet::SetItemText( sal_uInt16 nItemId, const XubString& rText )
2131 : {
2132 0 : size_t nPos = GetItemPos( nItemId );
2133 :
2134 0 : if ( nPos == VALUESET_ITEM_NOTFOUND )
2135 0 : return;
2136 :
2137 :
2138 0 : ValueSetItem* pItem = mItemList[nPos];
2139 :
2140 : // Remember old and new name for accessibility event.
2141 0 : ::com::sun::star::uno::Any aOldName, aNewName;
2142 0 : ::rtl::OUString sString (pItem->maText);
2143 0 : aOldName <<= sString;
2144 0 : sString = rText;
2145 0 : aNewName <<= sString;
2146 :
2147 0 : pItem->maText = rText;
2148 :
2149 0 : if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
2150 : {
2151 0 : sal_uInt16 nTempId = mnSelItemId;
2152 :
2153 0 : if ( mbHighlight )
2154 0 : nTempId = mnHighItemId;
2155 :
2156 0 : if ( nTempId == nItemId )
2157 0 : ImplDrawItemText( pItem->maText );
2158 : }
2159 :
2160 0 : if (ImplHasAccessibleListeners())
2161 : {
2162 : ::com::sun::star::uno::Reference<
2163 : ::com::sun::star::accessibility::XAccessible> xAccessible (
2164 0 : pItem->GetAccessible( mbIsTransientChildrenDisabled ) );
2165 0 : static_cast<ValueItemAcc*>(xAccessible.get())->FireAccessibleEvent (
2166 : ::com::sun::star::accessibility::AccessibleEventId::NAME_CHANGED,
2167 0 : aOldName, aNewName);
2168 0 : }
2169 : }
2170 :
2171 : // -----------------------------------------------------------------------
2172 :
2173 0 : XubString ValueSet::GetItemText( sal_uInt16 nItemId ) const
2174 : {
2175 0 : size_t nPos = GetItemPos( nItemId );
2176 :
2177 0 : if ( nPos != VALUESET_ITEM_NOTFOUND )
2178 0 : return mItemList[nPos]->maText;
2179 : else
2180 0 : return XubString();
2181 : }
2182 :
2183 : // -----------------------------------------------------------------------
2184 :
2185 0 : void ValueSet::SetColor( const Color& rColor )
2186 : {
2187 0 : maColor = rColor;
2188 0 : mbFormat = true;
2189 0 : if ( IsReallyVisible() && IsUpdateMode() )
2190 0 : ImplDraw();
2191 0 : }
2192 :
2193 : // -----------------------------------------------------------------------
2194 :
2195 0 : void ValueSet::SetExtraSpacing( sal_uInt16 nNewSpacing )
2196 : {
2197 0 : if ( GetStyle() & WB_ITEMBORDER )
2198 : {
2199 0 : mnSpacing = nNewSpacing;
2200 :
2201 0 : mbFormat = true;
2202 0 : if ( IsReallyVisible() && IsUpdateMode() )
2203 0 : Invalidate();
2204 : }
2205 0 : }
2206 :
2207 : // -----------------------------------------------------------------------
2208 :
2209 0 : void ValueSet::StartSelection()
2210 : {
2211 0 : mbHighlight = true;
2212 0 : mbSelection = true;
2213 0 : mnHighItemId = mnSelItemId;
2214 0 : }
2215 :
2216 : // -----------------------------------------------------------------------
2217 :
2218 0 : void ValueSet::EndSelection()
2219 : {
2220 0 : if ( mbHighlight )
2221 : {
2222 0 : if ( IsTracking() )
2223 0 : EndTracking( ENDTRACK_CANCEL );
2224 :
2225 0 : ImplHighlightItem( mnSelItemId );
2226 0 : mbHighlight = false;
2227 : }
2228 0 : mbSelection = false;
2229 0 : }
2230 :
2231 : // -----------------------------------------------------------------------
2232 :
2233 0 : bool ValueSet::StartDrag( const CommandEvent& rCEvt, Region& rRegion )
2234 : {
2235 0 : if ( rCEvt.GetCommand() != COMMAND_STARTDRAG )
2236 0 : return false;
2237 :
2238 : // if necessary abort an existing action
2239 0 : EndSelection();
2240 :
2241 : // Check out if the the clicked on page is selected. If this is not the
2242 : // case set it as the current item. We only check mouse actions since
2243 : // drag-and-drop can also be triggered by the keyboard
2244 : sal_uInt16 nSelId;
2245 0 : if ( rCEvt.IsMouseEvent() )
2246 0 : nSelId = GetItemId( rCEvt.GetMousePosPixel() );
2247 : else
2248 0 : nSelId = mnSelItemId;
2249 :
2250 : // don't activate dragging if no item was clicked on
2251 0 : if ( !nSelId )
2252 0 : return false;
2253 :
2254 : // Check out if the page was selected. If not set as current page and
2255 : // call select.
2256 0 : if ( nSelId != mnSelItemId )
2257 : {
2258 0 : SelectItem( nSelId );
2259 0 : Update();
2260 0 : Select();
2261 : }
2262 :
2263 0 : Region aRegion;
2264 :
2265 : // assign region
2266 0 : rRegion = aRegion;
2267 :
2268 0 : return true;
2269 : }
2270 :
2271 : // -----------------------------------------------------------------------
2272 :
2273 0 : Size ValueSet::CalcWindowSizePixel( const Size& rItemSize, sal_uInt16 nDesireCols,
2274 : sal_uInt16 nDesireLines )
2275 : {
2276 0 : size_t nCalcCols = nDesireCols;
2277 0 : size_t nCalcLines = nDesireLines;
2278 :
2279 0 : if ( !nCalcCols )
2280 : {
2281 0 : if ( mnUserCols )
2282 0 : nCalcCols = mnUserCols;
2283 : else
2284 0 : nCalcCols = 1;
2285 : }
2286 :
2287 0 : if ( !nCalcLines )
2288 : {
2289 0 : nCalcLines = mnVisLines;
2290 :
2291 0 : if ( mbFormat )
2292 : {
2293 0 : if ( mnUserVisLines )
2294 0 : nCalcLines = mnUserVisLines;
2295 : else
2296 : {
2297 : // Floor( (M+N-1)/N )==Ceiling( M/N )
2298 0 : nCalcLines = (mItemList.size()+nCalcCols-1) / nCalcCols;
2299 0 : if ( !nCalcLines )
2300 0 : nCalcLines = 1;
2301 : }
2302 : }
2303 : }
2304 :
2305 0 : Size aSize( rItemSize.Width()*nCalcCols, rItemSize.Height()*nCalcLines );
2306 0 : WinBits nStyle = GetStyle();
2307 0 : long nTxtHeight = GetTextHeight();
2308 : long n;
2309 :
2310 0 : if ( nStyle & WB_ITEMBORDER )
2311 : {
2312 0 : if ( nStyle & WB_DOUBLEBORDER )
2313 0 : n = ITEM_OFFSET_DOUBLE;
2314 : else
2315 0 : n = ITEM_OFFSET;
2316 :
2317 0 : aSize.Width() += n*nCalcCols;
2318 0 : aSize.Height() += n*nCalcLines;
2319 : }
2320 : else
2321 0 : n = 0;
2322 :
2323 0 : if ( mnSpacing )
2324 : {
2325 0 : aSize.Width() += mnSpacing*(nCalcCols-1);
2326 0 : aSize.Height() += mnSpacing*(nCalcLines-1);
2327 : }
2328 :
2329 0 : if ( nStyle & WB_NAMEFIELD )
2330 : {
2331 0 : aSize.Height() += nTxtHeight + NAME_OFFSET;
2332 0 : if ( !(nStyle & WB_FLATVALUESET) )
2333 0 : aSize.Height() += NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
2334 : }
2335 :
2336 0 : if ( nStyle & WB_NONEFIELD )
2337 : {
2338 0 : aSize.Height() += nTxtHeight + n + mnSpacing;
2339 0 : if ( nStyle & WB_RADIOSEL )
2340 0 : aSize.Height() += 8;
2341 : }
2342 :
2343 : // sum possible ScrollBar width
2344 0 : aSize.Width() += GetScrollWidth();
2345 :
2346 0 : return aSize;
2347 : }
2348 :
2349 : // -----------------------------------------------------------------------
2350 :
2351 0 : Size ValueSet::CalcItemSizePixel( const Size& rItemSize, bool bOut ) const
2352 : {
2353 0 : Size aSize = rItemSize;
2354 :
2355 0 : WinBits nStyle = GetStyle();
2356 0 : if ( nStyle & WB_ITEMBORDER )
2357 : {
2358 : long n;
2359 :
2360 0 : if ( nStyle & WB_DOUBLEBORDER )
2361 0 : n = ITEM_OFFSET_DOUBLE;
2362 : else
2363 0 : n = ITEM_OFFSET;
2364 :
2365 0 : if ( bOut )
2366 : {
2367 0 : aSize.Width() += n;
2368 0 : aSize.Height() += n;
2369 : }
2370 : else
2371 : {
2372 0 : aSize.Width() -= n;
2373 0 : aSize.Height() -= n;
2374 : }
2375 : }
2376 :
2377 0 : return aSize;
2378 : }
2379 :
2380 : // -----------------------------------------------------------------------
2381 :
2382 0 : long ValueSet::GetScrollWidth() const
2383 : {
2384 0 : if ( GetStyle() & WB_VSCROLL )
2385 : {
2386 0 : ((ValueSet*)this)->ImplInitScrollBar();
2387 0 : return mpScrBar->GetSizePixel().Width()+SCRBAR_OFFSET;
2388 : }
2389 : else
2390 0 : return 0;
2391 : }
2392 :
2393 : // -----------------------------------------------------------------------
2394 :
2395 0 : void ValueSet::SetHighlightHdl( const Link& rLink )
2396 : {
2397 0 : maHighlightHdl = rLink;
2398 0 : }
2399 :
2400 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
