1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svtools.hxx"
26 #include <tools/list.hxx>
27 #include <tools/debug.hxx>
28 #include <vcl/decoview.hxx>
29 #include <vcl/svapp.hxx>
30 #ifndef _SCRBAR_HXX
31 #include <vcl/scrbar.hxx>
32 #endif
33 #ifndef _HELP_HXX
34 #include <vcl/help.hxx>
35 #endif
36 #include <com/sun/star/accessibility/AccessibleEventObject.hpp>
37 #include <com/sun/star/accessibility/AccessibleEventId.hpp>
38 #include <com/sun/star/accessibility/AccessibleStateType.hpp>
39 #include <com/sun/star/lang/XComponent.hpp>
40 #include <rtl/ustring.hxx>
41 #include "valueimp.hxx"
42
43 #define _SV_VALUESET_CXX
44 #include <svtools/valueset.hxx>
45
46 // ------------
47 // - ValueSet -
48 // ------------
49
ImplInit()50 void ValueSet::ImplInit()
51 {
52 // Size aWinSize = GetSizePixel();
53 mpImpl = new ValueSet_Impl;
54 mpNoneItem = NULL;
55 mpScrBar = NULL;
56 mnTextOffset = 0;
57 mnVisLines = 0;
58 mnLines = 0;
59 mnUserItemWidth = 0;
60 mnUserItemHeight = 0;
61 mnFirstLine = 0;
62 mnOldItemId = 0;
63 mnSelItemId = 0;
64 mnHighItemId = 0;
65 mnDropPos = VALUESET_ITEM_NOTFOUND;
66 mnCols = 0;
67 mnCurCol = 0;
68 mnUserCols = 0;
69 mnUserVisLines = 0;
70 mnSpacing = 0;
71 mnFrameStyle = 0;
72 mbFormat = true;
73 mbHighlight = false;
74 mbSelection = false;
75 mbNoSelection = true;
76 mbDrawSelection = true;
77 mbBlackSel = false;
78 mbDoubleSel = false;
79 mbScroll = false;
80 mbDropPos = false;
81 mbFullMode = true;
82 mbEdgeBlending = false;
83
84 // #106446#, #106601# force mirroring of virtual device
85 maVirDev.EnableRTL( GetParent()->IsRTLEnabled() );
86
87 ImplInitSettings( sal_True, sal_True, sal_True );
88 }
89
90 // -----------------------------------------------------------------------
91
ValueSet(Window * pParent,WinBits nWinStyle,bool bDisableTransientChildren)92 ValueSet::ValueSet( Window* pParent, WinBits nWinStyle, bool bDisableTransientChildren ) :
93 Control( pParent, nWinStyle ),
94 maVirDev( *this ),
95 maColor( COL_TRANSPARENT )
96 {
97 ImplInit();
98 if( mpImpl )
99 mpImpl->mbIsTransientChildrenDisabled = bDisableTransientChildren;
100 }
101
102 // -----------------------------------------------------------------------
103
ValueSet(Window * pParent,const ResId & rResId,bool bDisableTransientChildren)104 ValueSet::ValueSet( Window* pParent, const ResId& rResId, bool bDisableTransientChildren ) :
105 Control( pParent, rResId ),
106 maVirDev( *this ),
107 maColor( COL_TRANSPARENT )
108 {
109 ImplInit();
110 if( mpImpl )
111 mpImpl->mbIsTransientChildrenDisabled = bDisableTransientChildren;
112 }
113
114 // -----------------------------------------------------------------------
115
~ValueSet()116 ValueSet::~ValueSet()
117 {
118 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XComponent>
119 xComponent (GetAccessible(sal_False), ::com::sun::star::uno::UNO_QUERY);
120 if (xComponent.is())
121 xComponent->dispose ();
122
123 if ( mpScrBar )
124 delete mpScrBar;
125
126 if ( mpNoneItem )
127 delete mpNoneItem;
128
129 ImplDeleteItems();
130 delete mpImpl;
131 }
132
133 // -----------------------------------------------------------------------
134
ImplDeleteItems()135 void ValueSet::ImplDeleteItems()
136 {
137 for( ValueSetItem* pItem = mpImpl->mpItemList->First(); pItem; pItem = mpImpl->mpItemList->Next() )
138 {
139 if( !pItem->maRect.IsEmpty() && ImplHasAccessibleListeners() )
140 {
141 ::com::sun::star::uno::Any aOldAny, aNewAny;
142
143 aOldAny <<= pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled );
144 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
145 }
146
147 delete pItem;
148 }
149
150 mpImpl->mpItemList->Clear();
151 }
152
153 // -----------------------------------------------------------------------
154
ImplInitSettings(sal_Bool bFont,sal_Bool bForeground,sal_Bool bBackground)155 void ValueSet::ImplInitSettings( sal_Bool bFont, sal_Bool bForeground, sal_Bool bBackground )
156 {
157 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
158
159 if ( bFont )
160 {
161 Font aFont;
162 aFont = rStyleSettings.GetAppFont();
163 if ( IsControlFont() )
164 aFont.Merge( GetControlFont() );
165 SetZoomedPointFont( aFont );
166 }
167
168 if ( bForeground || bFont )
169 {
170 Color aColor;
171 if ( IsControlForeground() )
172 aColor = GetControlForeground();
173 else
174 aColor = rStyleSettings.GetButtonTextColor();
175 SetTextColor( aColor );
176 SetTextFillColor();
177 }
178
179 if ( bBackground )
180 {
181 Color aColor;
182 if ( IsControlBackground() )
183 aColor = GetControlBackground();
184 else if ( GetStyle() & WB_MENUSTYLEVALUESET )
185 aColor = rStyleSettings.GetMenuColor();
186 else if ( IsEnabled() && (GetStyle() & WB_FLATVALUESET) )
187 aColor = rStyleSettings.GetWindowColor();
188 else
189 aColor = rStyleSettings.GetFaceColor();
190 SetBackground( aColor );
191 }
192 }
193
194 // -----------------------------------------------------------------------
195
ImplInitScrollBar()196 void ValueSet::ImplInitScrollBar()
197 {
198 if ( GetStyle() & WB_VSCROLL )
199 {
200 if ( !mpScrBar )
201 {
202 mpScrBar = new ScrollBar( this, WB_VSCROLL | WB_DRAG );
203 mpScrBar->SetScrollHdl( LINK( this, ValueSet, ImplScrollHdl ) );
204 }
205 else
206 {
207 // Wegen Einstellungsaenderungen passen wir hier die Breite an
208 long nScrBarWidth = GetSettings().GetStyleSettings().GetScrollBarSize();
209 mpScrBar->SetPosSizePixel( 0, 0, nScrBarWidth, 0, WINDOW_POSSIZE_WIDTH );
210 }
211 }
212 }
213
214 // -----------------------------------------------------------------------
215
ImplFormatItem(ValueSetItem * pItem)216 void ValueSet::ImplFormatItem( ValueSetItem* pItem )
217 {
218 if ( pItem->meType == VALUESETITEM_SPACE )
219 return;
220
221 Rectangle aRect = pItem->maRect;
222 WinBits nStyle = GetStyle();
223 if ( nStyle & WB_ITEMBORDER )
224 {
225 aRect.Left()++;
226 aRect.Top()++;
227 aRect.Right()--;
228 aRect.Bottom()--;
229 if ( nStyle & WB_FLATVALUESET )
230 {
231 if ( nStyle & WB_DOUBLEBORDER )
232 {
233 aRect.Left() += 2;
234 aRect.Top() += 2;
235 aRect.Right() -= 2;
236 aRect.Bottom() -= 2;
237 }
238 else
239 {
240 aRect.Left()++;
241 aRect.Top()++;
242 aRect.Right()--;
243 aRect.Bottom()--;
244 }
245 }
246 else
247 {
248 DecorationView aView( &maVirDev );
249 aRect = aView.DrawFrame( aRect, mnFrameStyle );
250 }
251 }
252
253 if ( pItem == mpNoneItem )
254 pItem->maText = GetText();
255
256 if ( (aRect.GetHeight() > 0) && (aRect.GetWidth() > 0) )
257 {
258 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
259
260 if ( pItem == mpNoneItem )
261 {
262 maVirDev.SetFont( GetFont() );
263 maVirDev.SetTextColor( ( nStyle & WB_MENUSTYLEVALUESET ) ? rStyleSettings.GetMenuTextColor() : rStyleSettings.GetWindowTextColor() );
264 maVirDev.SetTextFillColor();
265 maVirDev.SetFillColor( ( nStyle & WB_MENUSTYLEVALUESET ) ? rStyleSettings.GetMenuColor() : rStyleSettings.GetWindowColor() );
266 maVirDev.DrawRect( aRect );
267 Point aTxtPos( aRect.Left()+2, aRect.Top() );
268 long nTxtWidth = GetTextWidth( pItem->maText );
269 if ( nStyle & WB_RADIOSEL )
270 {
271 aTxtPos.X() += 4;
272 aTxtPos.Y() += 4;
273 }
274 if ( (aTxtPos.X()+nTxtWidth) > aRect.Right() )
275 {
276 maVirDev.SetClipRegion( Region( aRect ) );
277 maVirDev.DrawText( aTxtPos, pItem->maText );
278 maVirDev.SetClipRegion();
279 }
280 else
281 maVirDev.DrawText( aTxtPos, pItem->maText );
282 }
283 else if ( pItem->meType == VALUESETITEM_COLOR )
284 {
285 maVirDev.SetFillColor( pItem->maColor );
286 maVirDev.DrawRect( aRect );
287 }
288 else
289 {
290 if ( IsColor() )
291 maVirDev.SetFillColor( maColor );
292 else if ( nStyle & WB_MENUSTYLEVALUESET )
293 maVirDev.SetFillColor( rStyleSettings.GetMenuColor() );
294 else if ( IsEnabled() )
295 maVirDev.SetFillColor( rStyleSettings.GetWindowColor() );
296 else
297 maVirDev.SetFillColor( rStyleSettings.GetFaceColor() );
298 maVirDev.DrawRect( aRect );
299
300 if ( pItem->meType == VALUESETITEM_USERDRAW )
301 {
302 UserDrawEvent aUDEvt( &maVirDev, aRect, pItem->mnId );
303 UserDraw( aUDEvt );
304 }
305 else
306 {
307 Size aImageSize = pItem->maImage.GetSizePixel();
308 Size aRectSize = aRect.GetSize();
309 Point aPos( aRect.Left(), aRect.Top() );
310 aPos.X() += (aRectSize.Width()-aImageSize.Width())/2;
311 aPos.Y() += (aRectSize.Height()-aImageSize.Height())/2;
312
313 sal_uInt16 nImageStyle = 0;
314 if( !IsEnabled() )
315 nImageStyle |= IMAGE_DRAW_DISABLE;
316
317 if ( (aImageSize.Width() > aRectSize.Width()) ||
318 (aImageSize.Height() > aRectSize.Height()) )
319 {
320 maVirDev.SetClipRegion( Region( aRect ) );
321 maVirDev.DrawImage( aPos, pItem->maImage, nImageStyle);
322 maVirDev.SetClipRegion();
323 }
324 else
325 maVirDev.DrawImage( aPos, pItem->maImage, nImageStyle );
326 }
327 }
328
329 const sal_uInt16 nEdgeBlendingPercent(GetEdgeBlending() ? rStyleSettings.GetEdgeBlending() : 0);
330
331 if(nEdgeBlendingPercent)
332 {
333 const Color& rTopLeft(rStyleSettings.GetEdgeBlendingTopLeftColor());
334 const Color& rBottomRight(rStyleSettings.GetEdgeBlendingBottomRightColor());
335 const sal_uInt8 nAlpha((nEdgeBlendingPercent * 255) / 100);
336 const BitmapEx aBlendFrame(createBlendFrame(aRect.GetSize(), nAlpha, rTopLeft, rBottomRight));
337
338 if(!aBlendFrame.IsEmpty())
339 {
340 maVirDev.DrawBitmapEx(aRect.TopLeft(), aBlendFrame);
341 }
342 }
343 }
344 }
345
346 // -----------------------------------------------------------------------
347
CreateAccessible()348 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > ValueSet::CreateAccessible()
349 {
350 return new ValueSetAcc( this, mpImpl->mbIsTransientChildrenDisabled );
351 }
352
353 // -----------------------------------------------------------------------
354
Format()355 void ValueSet::Format()
356 {
357 Size aWinSize = GetOutputSizePixel();
358 sal_uLong nItemCount = mpImpl->mpItemList->Count();
359 WinBits nStyle = GetStyle();
360 long nTxtHeight = GetTextHeight();
361 long nOff;
362 long nSpace;
363 long nNoneHeight;
364 long nNoneSpace;
365 ScrollBar* pDelScrBar = NULL;
366
367 // Scrolling beruecksichtigen
368 if ( nStyle & WB_VSCROLL )
369 ImplInitScrollBar();
370 else
371 {
372 if ( mpScrBar )
373 {
374 // ScrollBar erst spaeter zerstoeren, damit keine rekursiven
375 // Aufrufe entstehen koennen
376 pDelScrBar = mpScrBar;
377 mpScrBar = NULL;
378 }
379 }
380
381 // Item-Offset berechnen
382 if ( nStyle & WB_ITEMBORDER )
383 {
384 if ( nStyle & WB_DOUBLEBORDER )
385 nOff = ITEM_OFFSET_DOUBLE;
386 else
387 nOff = ITEM_OFFSET;
388 }
389 else
390 nOff = 0;
391 nSpace = mnSpacing;
392
393 // Groesse beruecksichtigen, wenn NameField vorhanden
394 if ( nStyle & WB_NAMEFIELD )
395 {
396 mnTextOffset = aWinSize.Height()-nTxtHeight-NAME_OFFSET;
397 aWinSize.Height() -= nTxtHeight+NAME_OFFSET;
398
399 if ( !(nStyle & WB_FLATVALUESET) )
400 {
401 mnTextOffset -= NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
402 aWinSize.Height() -= NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
403 }
404 }
405 else
406 mnTextOffset = 0;
407
408 // Offset und Groesse beruecksichtigen, wenn NoneField vorhanden
409 if ( nStyle & WB_NONEFIELD )
410 {
411 nNoneHeight = nTxtHeight+nOff;
412 nNoneSpace = nSpace;
413 if ( nStyle & WB_RADIOSEL )
414 nNoneHeight += 8;
415 }
416 else
417 {
418 nNoneHeight = 0;
419 nNoneSpace = 0;
420
421 if ( mpNoneItem )
422 {
423 delete mpNoneItem;
424 mpNoneItem = NULL;
425 }
426 }
427
428 // Breite vom ScrollBar berechnen
429 long nScrBarWidth = 0;
430 if ( mpScrBar )
431 nScrBarWidth = mpScrBar->GetSizePixel().Width()+SCRBAR_OFFSET;
432
433 // Spaltenanzahl berechnen
434 if ( !mnUserCols )
435 {
436 if ( mnUserItemWidth )
437 {
438 mnCols = (sal_uInt16)((aWinSize.Width()-nScrBarWidth+nSpace) / (mnUserItemWidth+nSpace));
439 if ( !mnCols )
440 mnCols = 1;
441 }
442 else
443 mnCols = 1;
444 }
445 else
446 mnCols = mnUserCols;
447
448 // Zeilenanzahl berechnen
449 mbScroll = false;
450 mnLines = (long)mpImpl->mpItemList->Count() / mnCols;
451 if ( mpImpl->mpItemList->Count() % mnCols )
452 mnLines++;
453 else if ( !mnLines )
454 mnLines = 1;
455
456 long nCalcHeight = aWinSize.Height()-nNoneHeight;
457 if ( mnUserVisLines )
458 mnVisLines = mnUserVisLines;
459 else if ( mnUserItemHeight )
460 {
461 mnVisLines = (nCalcHeight-nNoneSpace+nSpace) / (mnUserItemHeight+nSpace);
462 if ( !mnVisLines )
463 mnVisLines = 1;
464 }
465 else
466 mnVisLines = mnLines;
467 if ( mnLines > mnVisLines )
468 mbScroll = true;
469 if ( mnLines <= mnVisLines )
470 mnFirstLine = 0;
471 else
472 {
473 if ( mnFirstLine > (sal_uInt16)(mnLines-mnVisLines) )
474 mnFirstLine = (sal_uInt16)(mnLines-mnVisLines);
475 }
476
477 // Itemgroessen berechnen
478 long nColSpace = (mnCols-1)*nSpace;
479 long nLineSpace = ((mnVisLines-1)*nSpace)+nNoneSpace;
480 long nItemWidth;
481 long nItemHeight;
482 if ( mnUserItemWidth && !mnUserCols )
483 {
484 nItemWidth = mnUserItemWidth;
485 if ( nItemWidth > aWinSize.Width()-nScrBarWidth-nColSpace )
486 nItemWidth = aWinSize.Width()-nScrBarWidth-nColSpace;
487 }
488 else
489 nItemWidth = (aWinSize.Width()-nScrBarWidth-nColSpace) / mnCols;
490 if ( mnUserItemHeight && !mnUserVisLines )
491 {
492 nItemHeight = mnUserItemHeight;
493 if ( nItemHeight > nCalcHeight-nNoneSpace )
494 nItemHeight = nCalcHeight-nNoneSpace;
495 }
496 else
497 {
498 nCalcHeight -= nLineSpace;
499 nItemHeight = nCalcHeight / mnVisLines;
500 }
501
502 // Init VirDev
503 maVirDev.SetSettings( GetSettings() );
504 maVirDev.SetBackground( GetBackground() );
505 maVirDev.SetOutputSizePixel( aWinSize, sal_True );
506
507 // Bei zu kleinen Items machen wir nichts
508 long nMinHeight = 2;
509 if ( nStyle & WB_ITEMBORDER )
510 nMinHeight = 4;
511 if ( (nItemWidth <= 0) || (nItemHeight <= nMinHeight) || !nItemCount )
512 {
513 if ( nStyle & WB_NONEFIELD )
514 {
515 if ( mpNoneItem )
516 {
517 mpNoneItem->maRect.SetEmpty();
518 mpNoneItem->maText = GetText();
519 }
520 }
521
522 for ( sal_uLong i = 0; i < nItemCount; i++ )
523 {
524 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( i );
525 pItem->maRect.SetEmpty();
526 }
527
528 if ( mpScrBar )
529 mpScrBar->Hide();
530 }
531 else
532 {
533 // Frame-Style ermitteln
534 if ( nStyle & WB_DOUBLEBORDER )
535 mnFrameStyle = FRAME_DRAW_DOUBLEIN;
536 else
537 mnFrameStyle = FRAME_DRAW_IN;
538
539 // Selektionsfarben und -breiten ermitteln
540 // Gegebenenfalls die Farben anpassen, damit man die Selektion besser
541 // erkennen kann
542 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
543 Color aHighColor( rStyleSettings.GetHighlightColor() );
544 if ( ((aHighColor.GetRed() > 0x80) || (aHighColor.GetGreen() > 0x80) ||
545 (aHighColor.GetBlue() > 0x80)) ||
546 ((aHighColor.GetRed() == 0x80) && (aHighColor.GetGreen() == 0x80) &&
547 (aHighColor.GetBlue() == 0x80)) )
548 mbBlackSel = true;
549 else
550 mbBlackSel = false;
551
552 // Wenn die Items groesser sind, dann die Selektion doppelt so breit
553 // zeichnen
554 if ( (nStyle & WB_DOUBLEBORDER) &&
555 ((nItemWidth >= 25) && (nItemHeight >= 20)) )
556 mbDoubleSel = true;
557 else
558 mbDoubleSel = false;
559
560 // Calculate offsets
561 long nStartX;
562 long nStartY;
563 if ( mbFullMode )
564 {
565 long nAllItemWidth = (nItemWidth*mnCols)+nColSpace;
566 long nAllItemHeight = (nItemHeight*mnVisLines)+nNoneHeight+nLineSpace;
567 nStartX = (aWinSize.Width()-nScrBarWidth-nAllItemWidth)/2;
568 nStartY = (aWinSize.Height()-nAllItemHeight)/2;
569 }
570 else
571 {
572 nStartX = 0;
573 nStartY = 0;
574 }
575
576 // Items berechnen und zeichnen
577 maVirDev.SetLineColor();
578 long x = nStartX;
579 long y = nStartY;
580
581 // NoSelection-Field erzeugen und anzeigen
582 if ( nStyle & WB_NONEFIELD )
583 {
584 if ( !mpNoneItem )
585 mpNoneItem = new ValueSetItem( *this );
586
587 mpNoneItem->mnId = 0;
588 mpNoneItem->meType = VALUESETITEM_NONE;
589 mpNoneItem->maRect.Left() = x;
590 mpNoneItem->maRect.Top() = y;
591 mpNoneItem->maRect.Right() = mpNoneItem->maRect.Left()+aWinSize.Width()-x-1;
592 mpNoneItem->maRect.Bottom() = y+nNoneHeight-1;
593
594 ImplFormatItem( mpNoneItem );
595
596 y += nNoneHeight+nNoneSpace;
597 }
598
599 // draw items
600 sal_uLong nFirstItem = mnFirstLine * mnCols;
601 sal_uLong nLastItem = nFirstItem + (mnVisLines * mnCols);
602
603 if ( !mbFullMode )
604 {
605 // If want also draw parts of items in the last line,
606 // then we add one more line if parts of these line are
607 // visible
608 if ( y+(mnVisLines*(nItemHeight+nSpace)) < aWinSize.Height() )
609 nLastItem += mnCols;
610 }
611 for ( sal_uLong i = 0; i < nItemCount; i++ )
612 {
613 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( i );
614
615 if ( (i >= nFirstItem) && (i < nLastItem) )
616 {
617 const sal_Bool bWasEmpty = pItem->maRect.IsEmpty();
618
619 pItem->maRect.Left() = x;
620 pItem->maRect.Top() = y;
621 pItem->maRect.Right() = pItem->maRect.Left()+nItemWidth-1;
622 pItem->maRect.Bottom() = pItem->maRect.Top()+nItemHeight-1;
623
624 if( bWasEmpty && ImplHasAccessibleListeners() )
625 {
626 ::com::sun::star::uno::Any aOldAny, aNewAny;
627
628 aNewAny <<= pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled );
629 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
630 }
631
632 ImplFormatItem( pItem );
633
634 if ( !((i+1) % mnCols) )
635 {
636 x = nStartX;
637 y += nItemHeight+nSpace;
638 }
639 else
640 x += nItemWidth+nSpace;
641 }
642 else
643 {
644 if( !pItem->maRect.IsEmpty() && ImplHasAccessibleListeners() )
645 {
646 ::com::sun::star::uno::Any aOldAny, aNewAny;
647
648 aOldAny <<= pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled );
649 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::CHILD, aOldAny, aNewAny );
650 }
651
652 pItem->maRect.SetEmpty();
653 }
654 }
655
656 // ScrollBar anordnen, Werte setzen und anzeigen
657 if ( mpScrBar )
658 {
659 Point aPos( aWinSize.Width()-nScrBarWidth+SCRBAR_OFFSET, 0 );
660 Size aSize( nScrBarWidth-SCRBAR_OFFSET, aWinSize.Height() );
661 // If a none field is visible, then we center the scrollbar
662 if ( nStyle & WB_NONEFIELD )
663 {
664 aPos.Y() = nStartY+nNoneHeight+1;
665 aSize.Height() = ((nItemHeight+nSpace)*mnVisLines)-2-nSpace;
666 }
667 mpScrBar->SetPosSizePixel( aPos, aSize );
668 mpScrBar->SetRangeMax( mnLines );
669 mpScrBar->SetVisibleSize( mnVisLines );
670 mpScrBar->SetThumbPos( (long)mnFirstLine );
671 long nPageSize = mnVisLines;
672 if ( nPageSize < 1 )
673 nPageSize = 1;
674 mpScrBar->SetPageSize( nPageSize );
675 mpScrBar->Show();
676 }
677 }
678
679 // Jetzt haben wir formatiert und warten auf das naechste
680 mbFormat = false;
681
682 // ScrollBar loeschen
683 if ( pDelScrBar )
684 delete pDelScrBar;
685 }
686
687 // -----------------------------------------------------------------------
688
ImplDrawItemText(const XubString & rText)689 void ValueSet::ImplDrawItemText( const XubString& rText )
690 {
691 if ( !(GetStyle() & WB_NAMEFIELD) )
692 return;
693
694 Size aWinSize = GetOutputSizePixel();
695 long nTxtWidth = GetTextWidth( rText );
696 long nTxtOffset = mnTextOffset;
697
698 // Rechteck loeschen und Text ausgeben
699 if ( GetStyle() & WB_FLATVALUESET )
700 {
701 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
702 SetLineColor();
703 SetFillColor( rStyleSettings.GetFaceColor() );
704 DrawRect( Rectangle( Point( 0, nTxtOffset ), Point( aWinSize.Width(), aWinSize.Height() ) ) );
705 SetTextColor( rStyleSettings.GetButtonTextColor() );
706 }
707 else
708 {
709 nTxtOffset += NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
710 Erase( Rectangle( Point( 0, nTxtOffset ), Point( aWinSize.Width(), aWinSize.Height() ) ) );
711 }
712 DrawText( Point( (aWinSize.Width()-nTxtWidth) / 2, nTxtOffset+(NAME_OFFSET/2) ), rText );
713 }
714
715 // -----------------------------------------------------------------------
716
ImplDrawSelect()717 void ValueSet::ImplDrawSelect()
718 {
719 if ( !IsReallyVisible() )
720 return;
721
722 sal_Bool bFocus = HasFocus();
723 sal_Bool bDrawSel;
724
725 if ( (mbNoSelection && !mbHighlight) || (!mbDrawSelection && mbHighlight) )
726 bDrawSel = sal_False;
727 else
728 bDrawSel = sal_True;
729
730 if ( !bFocus &&
731 ((mbNoSelection && !mbHighlight) || (!mbDrawSelection && mbHighlight)) )
732 {
733 XubString aEmptyStr;
734 ImplDrawItemText( aEmptyStr );
735 return;
736 }
737
738 sal_uInt16 nItemId = mnSelItemId;
739
740 for( int stage = 0; stage < 2; stage++ )
741 {
742 if( stage == 1 )
743 {
744 if ( mbHighlight )
745 nItemId = mnHighItemId;
746 else
747 break;
748 }
749
750 ValueSetItem* pItem;
751 if ( nItemId )
752 pItem = mpImpl->mpItemList->GetObject( GetItemPos( nItemId ) );
753 else
754 {
755 if ( mpNoneItem )
756 pItem = mpNoneItem;
757 else
758 {
759 pItem = ImplGetFirstItem();
760 if ( !bFocus || !pItem )
761 continue;
762 }
763 }
764
765 if ( pItem->maRect.IsEmpty() )
766 continue;
767
768 // Selection malen
769 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
770 Rectangle aRect = pItem->maRect;
771 Control::SetFillColor();
772
773 Color aDoubleColor( rStyleSettings.GetHighlightColor() );
774 Color aSingleColor( rStyleSettings.GetHighlightTextColor() );
775 if( ! mbDoubleSel )
776 {
777 /*
778 * #99777# contrast enhancement for thin mode
779 */
780 const Wallpaper& rWall = GetDisplayBackground();
781 if( ! rWall.IsBitmap() && ! rWall.IsGradient() )
782 {
783 const Color& rBack = rWall.GetColor();
784 if( rBack.IsDark() && ! aDoubleColor.IsBright() )
785 {
786 aDoubleColor = Color( COL_WHITE );
787 aSingleColor = Color( COL_BLACK );
788 }
789 else if( rBack.IsBright() && ! aDoubleColor.IsDark() )
790 {
791 aDoubleColor = Color( COL_BLACK );
792 aSingleColor = Color( COL_WHITE );
793 }
794 }
795 }
796
797 // Selectionsausgabe festlegen
798 WinBits nStyle = GetStyle();
799 if ( nStyle & WB_MENUSTYLEVALUESET )
800 {
801 if ( bFocus )
802 ShowFocus( aRect );
803
804 if ( bDrawSel )
805 {
806 if ( mbBlackSel )
807 SetLineColor( Color( COL_BLACK ) );
808 else
809 SetLineColor( aDoubleColor );
810 DrawRect( aRect );
811 }
812 }
813 else if ( nStyle & WB_RADIOSEL )
814 {
815 aRect.Left() += 3;
816 aRect.Top() += 3;
817 aRect.Right() -= 3;
818 aRect.Bottom() -= 3;
819 if ( nStyle & WB_DOUBLEBORDER )
820 {
821 aRect.Left()++;
822 aRect.Top()++;
823 aRect.Right()--;
824 aRect.Bottom()--;
825 }
826
827 if ( bFocus )
828 ShowFocus( aRect );
829
830 aRect.Left()++;
831 aRect.Top()++;
832 aRect.Right()--;
833 aRect.Bottom()--;
834
835 if ( bDrawSel )
836 {
837 SetLineColor( aDoubleColor );
838 aRect.Left()++;
839 aRect.Top()++;
840 aRect.Right()--;
841 aRect.Bottom()--;
842 DrawRect( aRect );
843 aRect.Left()++;
844 aRect.Top()++;
845 aRect.Right()--;
846 aRect.Bottom()--;
847 DrawRect( aRect );
848 }
849 }
850 else
851 {
852 if ( bDrawSel )
853 {
854 if ( mbBlackSel )
855 SetLineColor( Color( COL_BLACK ) );
856 else
857 SetLineColor( aDoubleColor );
858 DrawRect( aRect );
859 }
860 if ( mbDoubleSel )
861 {
862 aRect.Left()++;
863 aRect.Top()++;
864 aRect.Right()--;
865 aRect.Bottom()--;
866 if ( bDrawSel )
867 DrawRect( aRect );
868 }
869 aRect.Left()++;
870 aRect.Top()++;
871 aRect.Right()--;
872 aRect.Bottom()--;
873 Rectangle aRect2 = aRect;
874 aRect.Left()++;
875 aRect.Top()++;
876 aRect.Right()--;
877 aRect.Bottom()--;
878 if ( bDrawSel )
879 DrawRect( aRect );
880 if ( mbDoubleSel )
881 {
882 aRect.Left()++;
883 aRect.Top()++;
884 aRect.Right()--;
885 aRect.Bottom()--;
886 if ( bDrawSel )
887 DrawRect( aRect );
888 }
889
890 if ( bDrawSel )
891 {
892 if ( mbBlackSel )
893 SetLineColor( Color( COL_WHITE ) );
894 else
895 SetLineColor( aSingleColor );
896 }
897 else
898 SetLineColor( Color( COL_LIGHTGRAY ) );
899 DrawRect( aRect2 );
900
901 if ( bFocus )
902 ShowFocus( aRect2 );
903 }
904
905 ImplDrawItemText( pItem->maText );
906 }
907 }
908
909 // -----------------------------------------------------------------------
910
ImplHideSelect(sal_uInt16 nItemId)911 void ValueSet::ImplHideSelect( sal_uInt16 nItemId )
912 {
913 Rectangle aRect;
914
915 sal_uInt16 nItemPos = GetItemPos( nItemId );
916 if ( nItemPos != sal::static_int_cast<sal_uInt16>(LIST_ENTRY_NOTFOUND) )
917 aRect = mpImpl->mpItemList->GetObject( nItemPos )->maRect;
918 else
919 {
920 if ( mpNoneItem )
921 aRect = mpNoneItem->maRect;
922 }
923
924 if ( !aRect.IsEmpty() )
925 {
926 HideFocus();
927 Point aPos = aRect.TopLeft();
928 Size aSize = aRect.GetSize();
929 DrawOutDev( aPos, aSize, aPos, aSize, maVirDev );
930 }
931 }
932
933 // -----------------------------------------------------------------------
934
ImplHighlightItem(sal_uInt16 nItemId,sal_Bool bIsSelection)935 void ValueSet::ImplHighlightItem( sal_uInt16 nItemId, sal_Bool bIsSelection )
936 {
937 if ( mnHighItemId != nItemId )
938 {
939 // Alten merken, um vorherige Selektion zu entfernen
940 sal_uInt16 nOldItem = mnHighItemId;
941 mnHighItemId = nItemId;
942
943 // Wenn keiner selektiert ist, dann Selektion nicht malen
944 if ( !bIsSelection && mbNoSelection )
945 mbDrawSelection = false;
946
947 // Neu ausgeben und alte Selection wegnehmen
948 ImplHideSelect( nOldItem );
949 ImplDrawSelect();
950 mbDrawSelection = true;
951 }
952 }
953
954 // -----------------------------------------------------------------------
955
ImplDrawDropPos(sal_Bool bShow)956 void ValueSet::ImplDrawDropPos( sal_Bool bShow )
957 {
958 if ( (mnDropPos != VALUESET_ITEM_NOTFOUND) && mpImpl->mpItemList->Count() )
959 {
960 sal_uInt16 nItemPos = mnDropPos;
961 sal_uInt16 nItemId1;
962 sal_uInt16 nItemId2 = 0;
963 sal_Bool bRight;
964 if ( nItemPos >= mpImpl->mpItemList->Count() )
965 {
966 nItemPos = (sal_uInt16)(mpImpl->mpItemList->Count()-1);
967 bRight = sal_True;
968 }
969 else
970 bRight = sal_False;
971
972 nItemId1 = GetItemId( nItemPos );
973 if ( (nItemId1 != mnSelItemId) && (nItemId1 != mnHighItemId) )
974 nItemId1 = 0;
975 Rectangle aRect2 = mpImpl->mpItemList->GetObject( nItemPos )->maRect;
976 Rectangle aRect1;
977 if ( bRight )
978 {
979 aRect1 = aRect2;
980 aRect2.SetEmpty();
981 }
982 else if ( nItemPos > 0 )
983 {
984 aRect1 = mpImpl->mpItemList->GetObject( nItemPos-1 )->maRect;
985 nItemId2 = GetItemId( nItemPos-1 );
986 if ( (nItemId2 != mnSelItemId) && (nItemId2 != mnHighItemId) )
987 nItemId2 = 0;
988 }
989
990 // Items ueberhaupt sichtbar (nur Erstes/Letztes)
991 if ( !aRect1.IsEmpty() || !aRect2.IsEmpty() )
992 {
993 if ( nItemId1 )
994 ImplHideSelect( nItemId1 );
995 if ( nItemId2 )
996 ImplHideSelect( nItemId2 );
997
998 if ( bShow )
999 {
1000 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1001 long nX;
1002 long nY;
1003 SetLineColor( rStyleSettings.GetButtonTextColor() );
1004 if ( !aRect1.IsEmpty() )
1005 {
1006 Point aPos = aRect1.RightCenter();
1007 nX = aPos.X()-2;
1008 nY = aPos.Y();
1009 for ( sal_uInt16 i = 0; i < 4; i++ )
1010 DrawLine( Point( nX-i, nY-i ), Point( nX-i, nY+i ) );
1011 }
1012 if ( !aRect2.IsEmpty() )
1013 {
1014 Point aPos = aRect2.LeftCenter();
1015 nX = aPos.X()+2;
1016 nY = aPos.Y();
1017 for ( sal_uInt16 i = 0; i < 4; i++ )
1018 DrawLine( Point( nX+i, nY-i ), Point( nX+i, nY+i ) );
1019 }
1020 }
1021 else
1022 {
1023 if ( !aRect1.IsEmpty() )
1024 {
1025 Point aPos = aRect1.TopLeft();
1026 Size aSize = aRect1.GetSize();
1027 DrawOutDev( aPos, aSize, aPos, aSize, maVirDev );
1028 }
1029 if ( !aRect2.IsEmpty() )
1030 {
1031 Point aPos = aRect2.TopLeft();
1032 Size aSize = aRect2.GetSize();
1033 DrawOutDev( aPos, aSize, aPos, aSize, maVirDev );
1034 }
1035 }
1036
1037 if ( nItemId1 || nItemId2 )
1038 ImplDrawSelect();
1039 }
1040 }
1041 }
1042
1043 // -----------------------------------------------------------------------
1044
ImplDraw()1045 void ValueSet::ImplDraw()
1046 {
1047 if ( mbFormat )
1048 Format();
1049
1050 HideFocus();
1051
1052 Point aDefPos;
1053 Size aSize = maVirDev.GetOutputSizePixel();
1054
1055 if ( mpScrBar && mpScrBar->IsVisible() )
1056 {
1057 Point aScrPos = mpScrBar->GetPosPixel();
1058 Size aScrSize = mpScrBar->GetSizePixel();
1059 Point aTempPos( 0, aScrPos.Y() );
1060 Size aTempSize( aSize.Width(), aScrPos.Y() );
1061
1062 DrawOutDev( aDefPos, aTempSize, aDefPos, aTempSize, maVirDev );
1063 aTempSize.Width() = aScrPos.X()-1;
1064 aTempSize.Height() = aScrSize.Height();
1065 DrawOutDev( aTempPos, aTempSize, aTempPos, aTempSize, maVirDev );
1066 aTempPos.Y() = aScrPos.Y()+aScrSize.Height();
1067 aTempSize.Width() = aSize.Width();
1068 aTempSize.Height() = aSize.Height()-aTempPos.Y();
1069 DrawOutDev( aTempPos, aTempSize, aTempPos, aTempSize, maVirDev );
1070 }
1071 else
1072 DrawOutDev( aDefPos, aSize, aDefPos, aSize, maVirDev );
1073
1074 // Trennlinie zum Namefield zeichnen
1075 if ( GetStyle() & WB_NAMEFIELD )
1076 {
1077 if ( !(GetStyle() & WB_FLATVALUESET) )
1078 {
1079 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1080 Size aWinSize = GetOutputSizePixel();
1081 Point aPos1( NAME_LINE_OFF_X, mnTextOffset+NAME_LINE_OFF_Y );
1082 Point aPos2( aWinSize.Width()-(NAME_LINE_OFF_X*2), mnTextOffset+NAME_LINE_OFF_Y );
1083 if ( !(rStyleSettings.GetOptions() & STYLE_OPTION_MONO) )
1084 {
1085 SetLineColor( rStyleSettings.GetShadowColor() );
1086 DrawLine( aPos1, aPos2 );
1087 aPos1.Y()++;
1088 aPos2.Y()++;
1089 SetLineColor( rStyleSettings.GetLightColor() );
1090 }
1091 else
1092 SetLineColor( rStyleSettings.GetWindowTextColor() );
1093 DrawLine( aPos1, aPos2 );
1094 }
1095 }
1096
1097 ImplDrawSelect();
1098 }
1099
1100 // -----------------------------------------------------------------------
1101
ImplScroll(const Point & rPos)1102 sal_Bool ValueSet::ImplScroll( const Point& rPos )
1103 {
1104 Size aOutSize = GetOutputSizePixel();
1105 long nScrBarWidth;
1106
1107 if ( mpScrBar )
1108 nScrBarWidth = mpScrBar->GetSizePixel().Width();
1109 else
1110 nScrBarWidth = 0;
1111
1112 if ( !mbScroll || (rPos.X() < 0) || (rPos.X() > aOutSize.Width()-nScrBarWidth) )
1113 return sal_False;
1114
1115 long nScrollOffset;
1116 sal_uInt16 nOldLine = mnFirstLine;
1117 const Rectangle& rTopRect = mpImpl->mpItemList->GetObject( mnFirstLine*mnCols )->maRect;
1118 if ( rTopRect.GetHeight() <= 16 )
1119 nScrollOffset = VALUESET_SCROLL_OFFSET/2;
1120 else
1121 nScrollOffset = VALUESET_SCROLL_OFFSET;
1122 if ( (mnFirstLine > 0) && (rPos.Y() >= 0) )
1123 {
1124 long nTopPos = rTopRect.Top();
1125 if ( (rPos.Y() >= nTopPos) && (rPos.Y() <= nTopPos+nScrollOffset) )
1126 mnFirstLine--;
1127 }
1128 if ( (mnFirstLine == nOldLine) &&
1129 (mnFirstLine < (sal_uInt16)(mnLines-mnVisLines)) && (rPos.Y() < aOutSize.Height()) )
1130 {
1131 long nBottomPos = mpImpl->mpItemList->GetObject( (mnFirstLine+mnVisLines-1)*mnCols )->maRect.Bottom();
1132 if ( (rPos.Y() >= nBottomPos-nScrollOffset) && (rPos.Y() <= nBottomPos) )
1133 mnFirstLine++;
1134 }
1135
1136 if ( mnFirstLine != nOldLine )
1137 {
1138 mbFormat = true;
1139 ImplDraw();
1140 return sal_True;
1141 }
1142 else
1143 return sal_False;
1144 }
1145
1146 // -----------------------------------------------------------------------
1147
ImplGetItem(const Point & rPos,sal_Bool bMove) const1148 sal_uInt16 ValueSet::ImplGetItem( const Point& rPos, sal_Bool bMove ) const
1149 {
1150 if ( mpNoneItem )
1151 {
1152 if ( mpNoneItem->maRect.IsInside( rPos ) )
1153 return VALUESET_ITEM_NONEITEM;
1154 }
1155
1156 Point aDefPos;
1157 Rectangle aWinRect( aDefPos, maVirDev.GetOutputSizePixel() );
1158
1159 sal_uLong nItemCount = mpImpl->mpItemList->Count();
1160 for ( sal_uLong i = 0; i < nItemCount; i++ )
1161 {
1162 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( i );
1163 if ( pItem->maRect.IsInside( rPos ) )
1164 {
1165 if ( aWinRect.IsInside( rPos ) )
1166 return (sal_uInt16)i;
1167 else
1168 return VALUESET_ITEM_NOTFOUND;
1169 }
1170 }
1171
1172 // Wenn Spacing gesetzt ist, wird der vorher selektierte
1173 // Eintrag zurueckgegeben, wenn die Maus noch nicht das Fenster
1174 // verlassen hat
1175 if ( bMove && mnSpacing && mnHighItemId )
1176 {
1177 if ( aWinRect.IsInside( rPos ) )
1178 return GetItemPos( mnHighItemId );
1179 }
1180
1181 return VALUESET_ITEM_NOTFOUND;
1182 }
1183
1184 // -----------------------------------------------------------------------
1185
ImplGetItem(sal_uInt16 nPos)1186 ValueSetItem* ValueSet::ImplGetItem( sal_uInt16 nPos )
1187 {
1188 if ( nPos == VALUESET_ITEM_NONEITEM )
1189 return mpNoneItem;
1190 else
1191 return mpImpl->mpItemList->GetObject( nPos );
1192 }
1193
1194 // -----------------------------------------------------------------------
1195
ImplGetFirstItem()1196 ValueSetItem* ValueSet::ImplGetFirstItem()
1197 {
1198 sal_uInt16 nItemCount = (sal_uInt16)mpImpl->mpItemList->Count();
1199 sal_uInt16 i = 0;
1200
1201 while ( i < nItemCount )
1202 {
1203 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( i );
1204 if ( pItem->meType != VALUESETITEM_SPACE )
1205 return pItem;
1206 i++;
1207 }
1208
1209 return NULL;
1210 }
1211
1212 // -----------------------------------------------------------------------
1213
ImplGetVisibleItemCount() const1214 sal_uInt16 ValueSet::ImplGetVisibleItemCount() const
1215 {
1216 sal_uInt16 nRet = 0;
1217
1218 for( sal_Int32 n = 0, nItemCount = mpImpl->mpItemList->Count(); n < nItemCount; n++ )
1219 {
1220 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( n );
1221
1222 //IAccessible2 implementation - also count empty rectangles as visible...
1223 if( pItem->meType != VALUESETITEM_SPACE )
1224 nRet++;
1225 }
1226
1227 return nRet;
1228 }
1229
1230 // -----------------------------------------------------------------------
1231
ImplGetVisibleItem(sal_uInt16 nVisiblePos)1232 ValueSetItem* ValueSet::ImplGetVisibleItem( sal_uInt16 nVisiblePos )
1233 {
1234 ValueSetItem* pRet = NULL;
1235 sal_uInt16 nFoundPos = 0;
1236
1237 for( sal_Int32 n = 0, nItemCount = mpImpl->mpItemList->Count(); ( n < nItemCount ) && !pRet; n++ )
1238 {
1239 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( n );
1240
1241 if( ( pItem->meType != VALUESETITEM_SPACE ) && !pItem->maRect.IsEmpty() && ( nVisiblePos == nFoundPos++ ) )
1242 pRet = pItem;
1243 }
1244
1245 return pRet;
1246 }
1247
1248 // -----------------------------------------------------------------------
1249
ImplFireAccessibleEvent(short nEventId,const::com::sun::star::uno::Any & rOldValue,const::com::sun::star::uno::Any & rNewValue)1250 void ValueSet::ImplFireAccessibleEvent( short nEventId, const ::com::sun::star::uno::Any& rOldValue, const ::com::sun::star::uno::Any& rNewValue )
1251 {
1252 ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );
1253
1254 if( pAcc )
1255 pAcc->FireAccessibleEvent( nEventId, rOldValue, rNewValue );
1256 }
1257
1258 // -----------------------------------------------------------------------
1259
ImplHasAccessibleListeners()1260 sal_Bool ValueSet::ImplHasAccessibleListeners()
1261 {
1262 ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );
1263 return( pAcc && pAcc->HasAccessibleListeners() );
1264 }
1265
1266 // -----------------------------------------------------------------------
1267
IMPL_LINK(ValueSet,ImplScrollHdl,ScrollBar *,pScrollBar)1268 IMPL_LINK( ValueSet,ImplScrollHdl, ScrollBar*, pScrollBar )
1269 {
1270 sal_uInt16 nNewFirstLine = (sal_uInt16)pScrollBar->GetThumbPos();
1271 if ( nNewFirstLine != mnFirstLine )
1272 {
1273 mnFirstLine = nNewFirstLine;
1274 mbFormat = true;
1275 ImplDraw();
1276 }
1277 return 0;
1278 }
1279
1280 // -----------------------------------------------------------------------
1281
IMPL_LINK(ValueSet,ImplTimerHdl,Timer *,EMPTYARG)1282 IMPL_LINK( ValueSet,ImplTimerHdl, Timer*, EMPTYARG )
1283 {
1284 ImplTracking( GetPointerPosPixel(), sal_True );
1285 return 0;
1286 }
1287
1288 // -----------------------------------------------------------------------
1289
ImplTracking(const Point & rPos,sal_Bool bRepeat)1290 void ValueSet::ImplTracking( const Point& rPos, sal_Bool bRepeat )
1291 {
1292 if ( bRepeat || mbSelection )
1293 {
1294 if ( ImplScroll( rPos ) )
1295 {
1296 if ( mbSelection )
1297 {
1298 maTimer.SetTimeoutHdl( LINK( this, ValueSet, ImplTimerHdl ) );
1299 maTimer.SetTimeout( GetSettings().GetMouseSettings().GetScrollRepeat() );
1300 maTimer.Start();
1301 }
1302 }
1303 }
1304
1305 ValueSetItem* pItem = ImplGetItem( ImplGetItem( rPos ) );
1306 if ( pItem && (pItem->meType != VALUESETITEM_SPACE) )
1307 {
1308 if( GetStyle() & WB_MENUSTYLEVALUESET )
1309 mbHighlight = true;
1310
1311 ImplHighlightItem( pItem->mnId );
1312 }
1313 else
1314 {
1315 if( GetStyle() & WB_MENUSTYLEVALUESET )
1316 mbHighlight = true;
1317
1318 ImplHighlightItem( mnSelItemId, sal_False );
1319 }
1320 }
1321
1322 // -----------------------------------------------------------------------
1323
ImplEndTracking(const Point & rPos,sal_Bool bCancel)1324 void ValueSet::ImplEndTracking( const Point& rPos, sal_Bool bCancel )
1325 {
1326 ValueSetItem* pItem;
1327
1328 // Bei Abbruch, den alten Status wieder herstellen
1329 if ( bCancel )
1330 pItem = NULL;
1331 else
1332 pItem = ImplGetItem( ImplGetItem( rPos ) );
1333
1334 if ( pItem && (pItem->meType != VALUESETITEM_SPACE) )
1335 {
1336 SelectItem( pItem->mnId );
1337 if ( !mbSelection && !(GetStyle() & WB_NOPOINTERFOCUS) )
1338 GrabFocus();
1339 mbHighlight = false;
1340 mbSelection = false;
1341 Select();
1342 }
1343 else
1344 {
1345 ImplHighlightItem( mnSelItemId, sal_False );
1346 mbHighlight = false;
1347 mbSelection = false;
1348 }
1349 }
1350
1351 // -----------------------------------------------------------------------
1352
MouseButtonDown(const MouseEvent & rMEvt)1353 void ValueSet::MouseButtonDown( const MouseEvent& rMEvt )
1354 {
1355 if ( rMEvt.IsLeft() )
1356 {
1357 ValueSetItem* pItem = ImplGetItem( ImplGetItem( rMEvt.GetPosPixel() ) );
1358 if ( mbSelection )
1359 {
1360 mbHighlight = true;
1361 if ( pItem && (pItem->meType != VALUESETITEM_SPACE) )
1362 {
1363 mnOldItemId = mnSelItemId;
1364 mnHighItemId = mnSelItemId;
1365 ImplHighlightItem( pItem->mnId );
1366 }
1367
1368 return;
1369 }
1370 else
1371 {
1372 if ( pItem && (pItem->meType != VALUESETITEM_SPACE) && !rMEvt.IsMod2() )
1373 {
1374 if ( (pItem->mnBits & VIB_NODOUBLECLICK) || (rMEvt.GetClicks() == 1) )
1375 {
1376 mnOldItemId = mnSelItemId;
1377 mbHighlight = true;
1378 mnHighItemId = mnSelItemId;
1379 ImplHighlightItem( pItem->mnId );
1380 StartTracking( STARTTRACK_SCROLLREPEAT );
1381 }
1382 else if ( rMEvt.GetClicks() == 2 )
1383 DoubleClick();
1384
1385 return;
1386 }
1387 }
1388 }
1389
1390 Control::MouseButtonDown( rMEvt );
1391 }
1392
1393 // -----------------------------------------------------------------------
1394
MouseButtonUp(const MouseEvent & rMEvt)1395 void ValueSet::MouseButtonUp( const MouseEvent& rMEvt )
1396 {
1397 // Wegen SelectionMode
1398 if ( rMEvt.IsLeft() && mbSelection )
1399 ImplEndTracking( rMEvt.GetPosPixel(), sal_False );
1400 else
1401 Control::MouseButtonUp( rMEvt );
1402 }
1403
1404 // -----------------------------------------------------------------------
1405
MouseMove(const MouseEvent & rMEvt)1406 void ValueSet::MouseMove( const MouseEvent& rMEvt )
1407 {
1408 // Wegen SelectionMode
1409 if ( mbSelection || (GetStyle() & WB_MENUSTYLEVALUESET) )
1410 ImplTracking( rMEvt.GetPosPixel(), sal_False );
1411 Control::MouseMove( rMEvt );
1412 }
1413
1414 // -----------------------------------------------------------------------
1415
Tracking(const TrackingEvent & rTEvt)1416 void ValueSet::Tracking( const TrackingEvent& rTEvt )
1417 {
1418 Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
1419
1420 if ( rTEvt.IsTrackingEnded() )
1421 ImplEndTracking( aMousePos, rTEvt.IsTrackingCanceled() );
1422 else
1423 ImplTracking( aMousePos, rTEvt.IsTrackingRepeat() );
1424 }
1425
1426 // -----------------------------------------------------------------------
1427
KeyInput(const KeyEvent & rKEvt)1428 void ValueSet::KeyInput( const KeyEvent& rKEvt )
1429 {
1430 sal_uInt16 nLastItem = (sal_uInt16)mpImpl->mpItemList->Count();
1431 sal_uInt16 nItemPos = VALUESET_ITEM_NOTFOUND;
1432 sal_uInt16 nCurPos = VALUESET_ITEM_NONEITEM;
1433 sal_uInt16 nCalcPos;
1434
1435 if ( !nLastItem || !ImplGetFirstItem() )
1436 {
1437 Control::KeyInput( rKEvt );
1438 return;
1439 }
1440 else
1441 nLastItem--;
1442
1443 if ( mnSelItemId )
1444 nCurPos = GetItemPos( mnSelItemId );
1445 nCalcPos = nCurPos;
1446
1447 //switch off selection mode if key travelling is used
1448 sal_Bool bDefault = sal_False;
1449 switch ( rKEvt.GetKeyCode().GetCode() )
1450 {
1451 case KEY_HOME:
1452 if ( mpNoneItem )
1453 nItemPos = VALUESET_ITEM_NONEITEM;
1454 else
1455 {
1456 nItemPos = 0;
1457 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE )
1458 nItemPos++;
1459 }
1460 break;
1461
1462 case KEY_END:
1463 nItemPos = nLastItem;
1464 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE )
1465 {
1466 if ( nItemPos == 0 )
1467 nItemPos = VALUESET_ITEM_NONEITEM;
1468 else
1469 nItemPos--;
1470 }
1471 break;
1472
1473 case KEY_LEFT:
1474 case KEY_RIGHT:
1475 if ( rKEvt.GetKeyCode().GetCode()==KEY_LEFT )
1476 {
1477 do
1478 {
1479 if ( nCalcPos == VALUESET_ITEM_NONEITEM )
1480 nItemPos = nLastItem;
1481 else if ( !nCalcPos )
1482 {
1483 if ( mpNoneItem )
1484 nItemPos = VALUESET_ITEM_NONEITEM;
1485 else
1486 nItemPos = nLastItem;
1487 }
1488 else
1489 nItemPos = nCalcPos-1;
1490 nCalcPos = nItemPos;
1491 }
1492 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE );
1493 }
1494 else
1495 {
1496 do
1497 {
1498 if ( nCalcPos == VALUESET_ITEM_NONEITEM )
1499 nItemPos = 0;
1500 else if ( nCalcPos == nLastItem )
1501 {
1502 if ( mpNoneItem )
1503 nItemPos = VALUESET_ITEM_NONEITEM;
1504 else
1505 nItemPos = 0;
1506 }
1507 else
1508 nItemPos = nCalcPos+1;
1509 nCalcPos = nItemPos;
1510 }
1511 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE );
1512 }
1513 break;
1514
1515 case KEY_UP:
1516 case KEY_PAGEUP:
1517 {
1518 if( rKEvt.GetKeyCode().GetCode() != KEY_PAGEUP ||
1519 ( !rKEvt.GetKeyCode().IsShift() && !rKEvt.GetKeyCode().IsMod1() && !rKEvt.GetKeyCode().IsMod2() ) )
1520 {
1521 const long nLineCount = ( ( KEY_UP == rKEvt.GetKeyCode().GetCode() ) ? 1 : mnVisLines );
1522 do
1523 {
1524 if ( nCalcPos == VALUESET_ITEM_NONEITEM )
1525 {
1526 if ( nLastItem+1 <= mnCols )
1527 nItemPos = mnCurCol;
1528 else
1529 {
1530 nItemPos = ((((nLastItem+1)/mnCols)-1)*mnCols)+(mnCurCol%mnCols);
1531 if ( nItemPos+mnCols <= nLastItem )
1532 nItemPos = nItemPos + mnCols;
1533 }
1534 }
1535 else if ( nCalcPos >= ( nLineCount * mnCols ) )
1536 nItemPos = sal::static_int_cast< sal_uInt16 >(
1537 nCalcPos - ( nLineCount * mnCols ));
1538 else
1539 {
1540 if ( mpNoneItem )
1541 {
1542 mnCurCol = nCalcPos%mnCols;
1543 nItemPos = VALUESET_ITEM_NONEITEM;
1544 }
1545 else
1546 {
1547 if ( nLastItem+1 <= mnCols )
1548 nItemPos = nCalcPos;
1549 else
1550 {
1551 nItemPos = ((((nLastItem+1)/mnCols)-1)*mnCols)+(nCalcPos%mnCols);
1552 if ( nItemPos+mnCols <= nLastItem )
1553 nItemPos = nItemPos + mnCols;
1554 }
1555 }
1556 }
1557 nCalcPos = nItemPos;
1558 }
1559 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE );
1560 }
1561 else
1562 Control::KeyInput( rKEvt );
1563 }
1564 break;
1565
1566 case KEY_DOWN:
1567 case KEY_PAGEDOWN:
1568 {
1569 if( rKEvt.GetKeyCode().GetCode() != KEY_PAGEDOWN ||
1570 ( !rKEvt.GetKeyCode().IsShift() && !rKEvt.GetKeyCode().IsMod1() && !rKEvt.GetKeyCode().IsMod2() ) )
1571 {
1572 const long nLineCount = ( ( KEY_DOWN == rKEvt.GetKeyCode().GetCode() ) ? 1 : mnVisLines );
1573 do
1574 {
1575 if ( nCalcPos == VALUESET_ITEM_NONEITEM )
1576 nItemPos = mnCurCol;
1577 else if ( nCalcPos + ( nLineCount * mnCols ) <= nLastItem )
1578 nItemPos = sal::static_int_cast< sal_uInt16 >(
1579 nCalcPos + ( nLineCount * mnCols ));
1580 else
1581 {
1582 #if 0
1583 if( (KEY_DOWN == rKEvt.GetKeyCode().GetCode() ) && (GetStyle() & WB_MENUSTYLEVALUESET) )
1584 {
1585 Window* pParent = GetParent();
1586 pParent->GrabFocus();
1587 pParent->KeyInput( rKEvt );
1588 break;
1589 }
1590 else
1591 #endif
1592 {
1593 if ( mpNoneItem )
1594 {
1595 mnCurCol = nCalcPos%mnCols;
1596 nItemPos = VALUESET_ITEM_NONEITEM;
1597 }
1598 else
1599 nItemPos = nCalcPos%mnCols;
1600 }
1601 }
1602 nCalcPos = nItemPos;
1603 }
1604 while ( ImplGetItem( nItemPos )->meType == VALUESETITEM_SPACE );
1605 }
1606 else
1607 Control::KeyInput( rKEvt );
1608
1609 }
1610 break;
1611 case KEY_RETURN:
1612 //enable default handling of KEY_RETURN in dialogs
1613 if(0 != (GetStyle()&WB_NO_DIRECTSELECT))
1614 {
1615 Select();
1616 break;
1617 }
1618 //no break;
1619 default:
1620 Control::KeyInput( rKEvt );
1621 bDefault = sal_True;
1622 break;
1623 }
1624 if(!bDefault)
1625 EndSelection();
1626 if ( nItemPos != VALUESET_ITEM_NOTFOUND )
1627 {
1628 sal_uInt16 nItemId;
1629 if ( nItemPos != VALUESET_ITEM_NONEITEM )
1630 nItemId = GetItemId( nItemPos );
1631 else
1632 nItemId = 0;
1633
1634 if ( nItemId != mnSelItemId )
1635 {
1636 SelectItem( nItemId );
1637 //select only if WB_NO_DIRECTSELECT is not set
1638 if(0 == (GetStyle()&WB_NO_DIRECTSELECT))
1639 Select();
1640 }
1641 }
1642 }
1643
1644 // -----------------------------------------------------------------------
1645
Command(const CommandEvent & rCEvt)1646 void ValueSet::Command( const CommandEvent& rCEvt )
1647 {
1648 if ( (rCEvt.GetCommand() == COMMAND_WHEEL) ||
1649 (rCEvt.GetCommand() == COMMAND_STARTAUTOSCROLL) ||
1650 (rCEvt.GetCommand() == COMMAND_AUTOSCROLL) )
1651 {
1652 if ( HandleScrollCommand( rCEvt, NULL, mpScrBar ) )
1653 return;
1654 }
1655
1656 Control::Command( rCEvt );
1657 }
1658
1659 // -----------------------------------------------------------------------
1660
Paint(const Rectangle &)1661 void ValueSet::Paint( const Rectangle& )
1662 {
1663 if ( GetStyle() & WB_FLATVALUESET )
1664 {
1665 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1666 SetLineColor();
1667 SetFillColor( rStyleSettings.GetFaceColor() );
1668 long nOffY = maVirDev.GetOutputSizePixel().Height();
1669 Size aWinSize = GetOutputSizePixel();
1670 DrawRect( Rectangle( Point( 0, nOffY ), Point( aWinSize.Width(), aWinSize.Height() ) ) );
1671 }
1672
1673 ImplDraw();
1674 }
1675
1676 // -----------------------------------------------------------------------
1677
GetFocus()1678 void ValueSet::GetFocus()
1679 {
1680 OSL_TRACE ("value set getting focus");
1681 ImplDrawSelect();
1682 Control::GetFocus();
1683
1684 // Tell the accessible object that we got the focus.
1685 ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );
1686 if( pAcc )
1687 pAcc->GetFocus();
1688 }
1689
1690 // -----------------------------------------------------------------------
1691
LoseFocus()1692 void ValueSet::LoseFocus()
1693 {
1694 OSL_TRACE ("value set losing focus");
1695 if ( mbNoSelection && mnSelItemId )
1696 ImplHideSelect( mnSelItemId );
1697 else
1698 HideFocus();
1699 Control::LoseFocus();
1700
1701 // Tell the accessible object that we lost the focus.
1702 ValueSetAcc* pAcc = ValueSetAcc::getImplementation( GetAccessible( sal_False ) );
1703 if( pAcc )
1704 pAcc->LoseFocus();
1705 }
1706
1707 // -----------------------------------------------------------------------
1708
Resize()1709 void ValueSet::Resize()
1710 {
1711 mbFormat = true;
1712 if ( IsReallyVisible() && IsUpdateMode() )
1713 Invalidate();
1714 Control::Resize();
1715 }
1716
1717 // -----------------------------------------------------------------------
1718
RequestHelp(const HelpEvent & rHEvt)1719 void ValueSet::RequestHelp( const HelpEvent& rHEvt )
1720 {
1721 if ( (rHEvt.GetMode() & (HELPMODE_QUICK | HELPMODE_BALLOON)) == HELPMODE_QUICK )
1722 {
1723 Point aPos = ScreenToOutputPixel( rHEvt.GetMousePosPixel() );
1724 sal_uInt16 nItemPos = ImplGetItem( aPos );
1725 if ( nItemPos != VALUESET_ITEM_NOTFOUND )
1726 {
1727 ValueSetItem* pItem = ImplGetItem( nItemPos );
1728 Rectangle aItemRect = pItem->maRect;
1729 Point aPt = OutputToScreenPixel( aItemRect.TopLeft() );
1730 aItemRect.Left() = aPt.X();
1731 aItemRect.Top() = aPt.Y();
1732 aPt = OutputToScreenPixel( aItemRect.BottomRight() );
1733 aItemRect.Right() = aPt.X();
1734 aItemRect.Bottom() = aPt.Y();
1735 Help::ShowQuickHelp( this, aItemRect, GetItemText( pItem->mnId ) );
1736 return;
1737 }
1738 }
1739
1740 Control::RequestHelp( rHEvt );
1741 }
1742
1743 // -----------------------------------------------------------------------
1744
StateChanged(StateChangedType nType)1745 void ValueSet::StateChanged( StateChangedType nType )
1746 {
1747 Control::StateChanged( nType );
1748
1749 if ( nType == STATE_CHANGE_INITSHOW )
1750 {
1751 if ( mbFormat )
1752 Format();
1753 }
1754 else if ( nType == STATE_CHANGE_UPDATEMODE )
1755 {
1756 if ( IsReallyVisible() && IsUpdateMode() )
1757 Invalidate();
1758 }
1759 else if ( nType == STATE_CHANGE_TEXT )
1760 {
1761 if ( mpNoneItem && !mbFormat && IsReallyVisible() && IsUpdateMode() )
1762 {
1763 ImplFormatItem( mpNoneItem );
1764 Invalidate( mpNoneItem->maRect );
1765 }
1766 }
1767 else if ( (nType == STATE_CHANGE_ZOOM) ||
1768 (nType == STATE_CHANGE_CONTROLFONT) )
1769 {
1770 ImplInitSettings( sal_True, sal_False, sal_False );
1771 Invalidate();
1772 }
1773 else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
1774 {
1775 ImplInitSettings( sal_False, sal_True, sal_False );
1776 Invalidate();
1777 }
1778 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
1779 {
1780 ImplInitSettings( sal_False, sal_False, sal_True );
1781 Invalidate();
1782 }
1783 else if ( (nType == STATE_CHANGE_STYLE) || (nType == STATE_CHANGE_ENABLE) )
1784 {
1785 mbFormat = true;
1786 ImplInitSettings( sal_False, sal_False, sal_True );
1787 Invalidate();
1788 }
1789 }
1790
1791 // -----------------------------------------------------------------------
1792
DataChanged(const DataChangedEvent & rDCEvt)1793 void ValueSet::DataChanged( const DataChangedEvent& rDCEvt )
1794 {
1795 Control::DataChanged( rDCEvt );
1796
1797 if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
1798 (rDCEvt.GetType() == DATACHANGED_DISPLAY) ||
1799 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
1800 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1801 (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
1802 {
1803 mbFormat = true;
1804 ImplInitSettings( sal_True, sal_True, sal_True );
1805 Invalidate();
1806 }
1807 }
1808
1809 // -----------------------------------------------------------------------
1810
Select()1811 void ValueSet::Select()
1812 {
1813 maSelectHdl.Call( this );
1814 }
1815
1816 // -----------------------------------------------------------------------
1817
DoubleClick()1818 void ValueSet::DoubleClick()
1819 {
1820 maDoubleClickHdl.Call( this );
1821 }
1822
1823 // -----------------------------------------------------------------------
1824
UserDraw(const UserDrawEvent &)1825 void ValueSet::UserDraw( const UserDrawEvent& )
1826 {
1827 }
1828
1829 // -----------------------------------------------------------------------
1830
InsertItem(sal_uInt16 nItemId,const Image & rImage,sal_uInt16 nPos)1831 void ValueSet::InsertItem( sal_uInt16 nItemId, const Image& rImage, sal_uInt16 nPos )
1832 {
1833 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
1834 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
1835 "ValueSet::InsertItem(): ItemId already exists" );
1836
1837 ValueSetItem* pItem = new ValueSetItem( *this );
1838 pItem->mnId = nItemId;
1839 pItem->meType = VALUESETITEM_IMAGE;
1840 pItem->maImage = rImage;
1841 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );
1842
1843 mbFormat = true;
1844 if ( IsReallyVisible() && IsUpdateMode() )
1845 Invalidate();
1846 }
1847
1848 // -----------------------------------------------------------------------
1849
InsertItem(sal_uInt16 nItemId,const Color & rColor,sal_uInt16 nPos)1850 void ValueSet::InsertItem( sal_uInt16 nItemId, const Color& rColor, sal_uInt16 nPos )
1851 {
1852 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
1853 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
1854 "ValueSet::InsertItem(): ItemId already exists" );
1855
1856 ValueSetItem* pItem = new ValueSetItem( *this );
1857 pItem->mnId = nItemId;
1858 pItem->meType = VALUESETITEM_COLOR;
1859 pItem->maColor = rColor;
1860 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );
1861
1862 mbFormat = true;
1863 if ( IsReallyVisible() && IsUpdateMode() )
1864 Invalidate();
1865 }
1866
1867 // -----------------------------------------------------------------------
1868
InsertItem(sal_uInt16 nItemId,const Image & rImage,const XubString & rText,sal_uInt16 nPos)1869 void ValueSet::InsertItem( sal_uInt16 nItemId, const Image& rImage,
1870 const XubString& rText, sal_uInt16 nPos )
1871 {
1872 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
1873 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
1874 "ValueSet::InsertItem(): ItemId already exists" );
1875
1876 ValueSetItem* pItem = new ValueSetItem( *this );
1877 pItem->mnId = nItemId;
1878 pItem->meType = VALUESETITEM_IMAGE;
1879 pItem->maImage = rImage;
1880 pItem->maText = rText;
1881 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );
1882
1883 mbFormat = true;
1884 if ( IsReallyVisible() && IsUpdateMode() )
1885 Invalidate();
1886 }
1887
1888 // -----------------------------------------------------------------------
1889
InsertItem(sal_uInt16 nItemId,const Color & rColor,const XubString & rText,sal_uInt16 nPos)1890 void ValueSet::InsertItem( sal_uInt16 nItemId, const Color& rColor,
1891 const XubString& rText, sal_uInt16 nPos )
1892 {
1893 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
1894 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
1895 "ValueSet::InsertItem(): ItemId already exists" );
1896
1897 ValueSetItem* pItem = new ValueSetItem( *this );
1898 pItem->mnId = nItemId;
1899 pItem->meType = VALUESETITEM_COLOR;
1900 pItem->maColor = rColor;
1901 pItem->maText = rText;
1902 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );
1903
1904 mbFormat = true;
1905 if ( IsReallyVisible() && IsUpdateMode() )
1906 Invalidate();
1907 }
1908
1909 //method to set accessible when the style is user draw.
InsertItem(sal_uInt16 nItemId,const XubString & rText,sal_uInt16 nPos)1910 void ValueSet::InsertItem( sal_uInt16 nItemId, const XubString& rText, sal_uInt16 nPos )
1911 {
1912 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
1913 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
1914 "ValueSet::InsertItem(): ItemId already exists" );
1915 ValueSetItem* pItem = new ValueSetItem( *this );
1916 pItem->mnId = nItemId;
1917 pItem->meType = VALUESETITEM_USERDRAW;
1918 pItem->maText = rText;
1919 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );
1920 mbFormat = sal_True;
1921 if ( IsReallyVisible() && IsUpdateMode() )
1922 Invalidate();
1923 }
1924
1925 // -----------------------------------------------------------------------
1926
InsertItem(sal_uInt16 nItemId,sal_uInt16 nPos)1927 void ValueSet::InsertItem( sal_uInt16 nItemId, sal_uInt16 nPos )
1928 {
1929 DBG_ASSERT( nItemId, "ValueSet::InsertItem(): ItemId == 0" );
1930 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
1931 "ValueSet::InsertItem(): ItemId already exists" );
1932
1933 ValueSetItem* pItem = new ValueSetItem( *this );
1934 pItem->mnId = nItemId;
1935 pItem->meType = VALUESETITEM_USERDRAW;
1936 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );
1937
1938 mbFormat = true;
1939 if ( IsReallyVisible() && IsUpdateMode() )
1940 Invalidate();
1941 }
1942
1943 // -----------------------------------------------------------------------
1944
InsertSpace(sal_uInt16 nItemId,sal_uInt16 nPos)1945 void ValueSet::InsertSpace( sal_uInt16 nItemId, sal_uInt16 nPos )
1946 {
1947 DBG_ASSERT( nItemId, "ValueSet::InsertSpace(): ItemId == 0" );
1948 DBG_ASSERT( GetItemPos( nItemId ) == VALUESET_ITEM_NOTFOUND,
1949 "ValueSet::InsertSpace(): ItemId already exists" );
1950
1951 ValueSetItem* pItem = new ValueSetItem( *this );
1952 pItem->mnId = nItemId;
1953 pItem->meType = VALUESETITEM_SPACE;
1954 mpImpl->mpItemList->Insert( pItem, (sal_uLong)nPos );
1955
1956 mbFormat = true;
1957 if ( IsReallyVisible() && IsUpdateMode() )
1958 Invalidate();
1959 }
1960
1961 // -----------------------------------------------------------------------
1962
RemoveItem(sal_uInt16 nItemId)1963 void ValueSet::RemoveItem( sal_uInt16 nItemId )
1964 {
1965 sal_uInt16 nPos = GetItemPos( nItemId );
1966
1967 if ( nPos == VALUESET_ITEM_NOTFOUND )
1968 return;
1969
1970 delete mpImpl->mpItemList->Remove( nPos );
1971
1972 // Variablen zuruecksetzen
1973 if ( (mnHighItemId == nItemId) || (mnSelItemId == nItemId) )
1974 {
1975 mnCurCol = 0;
1976 mnOldItemId = 0;
1977 mnHighItemId = 0;
1978 mnSelItemId = 0;
1979 mbNoSelection = true;
1980 }
1981
1982 mbFormat = true;
1983 if ( IsReallyVisible() && IsUpdateMode() )
1984 Invalidate();
1985 }
1986
1987 // -----------------------------------------------------------------------
1988
CopyItems(const ValueSet & rValueSet)1989 void ValueSet::CopyItems( const ValueSet& rValueSet )
1990 {
1991 ImplDeleteItems();
1992
1993 ValueSetItem* pItem = rValueSet.mpImpl->mpItemList->First();
1994 while ( pItem )
1995 {
1996 ValueSetItem* pNewItem = new ValueSetItem( *this );
1997
1998 pNewItem->mnId = pItem->mnId;
1999 pNewItem->mnBits = pItem->mnBits;
2000 pNewItem->meType = pItem->meType;
2001 pNewItem->maImage = pItem->maImage;
2002 pNewItem->maColor = pItem->maColor;
2003 pNewItem->maText = pItem->maText;
2004 pNewItem->mpData = pItem->mpData;
2005 pNewItem->maRect = pItem->maRect;
2006 pNewItem->mpxAcc = NULL;
2007
2008 mpImpl->mpItemList->Insert( pNewItem );
2009 pItem = rValueSet.mpImpl->mpItemList->Next();
2010 }
2011
2012 // Variablen zuruecksetzen
2013 mnFirstLine = 0;
2014 mnCurCol = 0;
2015 mnOldItemId = 0;
2016 mnHighItemId = 0;
2017 mnSelItemId = 0;
2018 mbNoSelection = true;
2019
2020 mbFormat = true;
2021 if ( IsReallyVisible() && IsUpdateMode() )
2022 Invalidate();
2023 }
2024
2025 // -----------------------------------------------------------------------
2026
Clear()2027 void ValueSet::Clear()
2028 {
2029 ImplDeleteItems();
2030
2031 // Variablen zuruecksetzen
2032 mnFirstLine = 0;
2033 mnCurCol = 0;
2034 mnOldItemId = 0;
2035 mnHighItemId = 0;
2036 mnSelItemId = 0;
2037 mbNoSelection = true;
2038
2039 mbFormat = true;
2040 if ( IsReallyVisible() && IsUpdateMode() )
2041 Invalidate();
2042 }
2043
2044 // -----------------------------------------------------------------------
2045
GetItemCount() const2046 sal_uInt16 ValueSet::GetItemCount() const
2047 {
2048 return (sal_uInt16)mpImpl->mpItemList->Count();
2049 }
2050
2051 // -----------------------------------------------------------------------
2052
GetItemPos(sal_uInt16 nItemId) const2053 sal_uInt16 ValueSet::GetItemPos( sal_uInt16 nItemId ) const
2054 {
2055 ValueSetItem* pItem = mpImpl->mpItemList->First();
2056 while ( pItem )
2057 {
2058 if ( pItem->mnId == nItemId )
2059 return (sal_uInt16)mpImpl->mpItemList->GetCurPos();
2060 pItem = mpImpl->mpItemList->Next();
2061 }
2062
2063 return VALUESET_ITEM_NOTFOUND;
2064 }
2065
2066 // -----------------------------------------------------------------------
2067
GetItemId(sal_uInt16 nPos) const2068 sal_uInt16 ValueSet::GetItemId( sal_uInt16 nPos ) const
2069 {
2070 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos );
2071
2072 if ( pItem )
2073 return pItem->mnId;
2074 else
2075 return 0;
2076 }
2077
2078 // -----------------------------------------------------------------------
2079
GetItemId(const Point & rPos) const2080 sal_uInt16 ValueSet::GetItemId( const Point& rPos ) const
2081 {
2082 sal_uInt16 nItemPos = ImplGetItem( rPos );
2083 if ( nItemPos != VALUESET_ITEM_NOTFOUND )
2084 return GetItemId( nItemPos );
2085
2086 return 0;
2087 }
2088
2089 // -----------------------------------------------------------------------
2090
GetItemRect(sal_uInt16 nItemId) const2091 Rectangle ValueSet::GetItemRect( sal_uInt16 nItemId ) const
2092 {
2093 sal_uInt16 nPos = GetItemPos( nItemId );
2094
2095 if ( nPos != VALUESET_ITEM_NOTFOUND )
2096 return mpImpl->mpItemList->GetObject( nPos )->maRect;
2097 else
2098 return Rectangle();
2099 }
2100
2101 // -----------------------------------------------------------------------
2102
EnableFullItemMode(bool bFullMode)2103 void ValueSet::EnableFullItemMode( bool bFullMode )
2104 {
2105 mbFullMode = bFullMode;
2106 }
2107
2108 // -----------------------------------------------------------------------
2109
SetColCount(sal_uInt16 nNewCols)2110 void ValueSet::SetColCount( sal_uInt16 nNewCols )
2111 {
2112 if ( mnUserCols != nNewCols )
2113 {
2114 mnUserCols = nNewCols;
2115 mbFormat = true;
2116 if ( IsReallyVisible() && IsUpdateMode() )
2117 Invalidate();
2118 }
2119 }
2120
2121 // -----------------------------------------------------------------------
2122
SetLineCount(sal_uInt16 nNewLines)2123 void ValueSet::SetLineCount( sal_uInt16 nNewLines )
2124 {
2125 if ( mnUserVisLines != nNewLines )
2126 {
2127 mnUserVisLines = nNewLines;
2128 mbFormat = true;
2129 if ( IsReallyVisible() && IsUpdateMode() )
2130 Invalidate();
2131 }
2132 }
2133
2134 // -----------------------------------------------------------------------
2135
SetItemWidth(long nNewItemWidth)2136 void ValueSet::SetItemWidth( long nNewItemWidth )
2137 {
2138 if ( mnUserItemWidth != nNewItemWidth )
2139 {
2140 mnUserItemWidth = nNewItemWidth;
2141 mbFormat = true;
2142 if ( IsReallyVisible() && IsUpdateMode() )
2143 Invalidate();
2144 }
2145 }
2146
2147 // -----------------------------------------------------------------------
2148
SetItemHeight(long nNewItemHeight)2149 void ValueSet::SetItemHeight( long nNewItemHeight )
2150 {
2151 if ( mnUserItemHeight != nNewItemHeight )
2152 {
2153 mnUserItemHeight = nNewItemHeight;
2154 mbFormat = true;
2155 if ( IsReallyVisible() && IsUpdateMode() )
2156 Invalidate();
2157 }
2158 }
2159
2160 // -----------------------------------------------------------------------
2161
SetFirstLine(sal_uInt16 nNewLine)2162 void ValueSet::SetFirstLine( sal_uInt16 nNewLine )
2163 {
2164 if ( mnFirstLine != nNewLine )
2165 {
2166 mnFirstLine = nNewLine;
2167 mbFormat = true;
2168 if ( IsReallyVisible() && IsUpdateMode() )
2169 Invalidate();
2170 }
2171 }
2172
2173 // -----------------------------------------------------------------------
2174
SelectItem(sal_uInt16 nItemId)2175 void ValueSet::SelectItem( sal_uInt16 nItemId )
2176 {
2177 sal_uInt16 nItemPos = 0;
2178
2179 if ( nItemId )
2180 {
2181 nItemPos = GetItemPos( nItemId );
2182 if ( nItemPos == VALUESET_ITEM_NOTFOUND )
2183 return;
2184 if ( mpImpl->mpItemList->GetObject( nItemPos )->meType == VALUESETITEM_SPACE )
2185 return;
2186 }
2187
2188 if ( (mnSelItemId != nItemId) || mbNoSelection )
2189 {
2190 sal_uInt16 nOldItem = mnSelItemId ? mnSelItemId : 1;
2191 mnSelItemId = nItemId;
2192 mbNoSelection = false;
2193
2194 sal_Bool bNewOut;
2195 sal_Bool bNewLine;
2196 if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
2197 bNewOut = sal_True;
2198 else
2199 bNewOut = sal_False;
2200 bNewLine = sal_False;
2201
2202 // Gegebenenfalls in den sichtbaren Bereich scrollen
2203 if ( mbScroll && nItemId )
2204 {
2205 sal_uInt16 nNewLine = (sal_uInt16)(nItemPos / mnCols);
2206 if ( nNewLine < mnFirstLine )
2207 {
2208 mnFirstLine = nNewLine;
2209 bNewLine = sal_True;
2210 }
2211 else if ( nNewLine > (sal_uInt16)(mnFirstLine+mnVisLines-1) )
2212 {
2213 mnFirstLine = (sal_uInt16)(nNewLine-mnVisLines+1);
2214 bNewLine = sal_True;
2215 }
2216 }
2217
2218 if ( bNewOut )
2219 {
2220 if ( bNewLine )
2221 {
2222 // Falls sich der sichtbare Bereich geaendert hat,
2223 // alles neu ausgeben
2224 mbFormat = true;
2225 ImplDraw();
2226 }
2227 else
2228 {
2229 // alte Selection wegnehmen und neue ausgeben
2230 ImplHideSelect( nOldItem );
2231 ImplDrawSelect();
2232 }
2233 }
2234
2235 if( ImplHasAccessibleListeners() )
2236 {
2237 // focus event (deselect)
2238 if( nOldItem )
2239 {
2240 const sal_uInt16 nPos = GetItemPos( nItemId );
2241
2242 if( nPos != VALUESET_ITEM_NOTFOUND )
2243 {
2244 ValueItemAcc* pItemAcc = ValueItemAcc::getImplementation(
2245 mpImpl->mpItemList->GetObject( nPos )->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ) );
2246
2247 if( pItemAcc )
2248 {
2249 ::com::sun::star::uno::Any aOldAny, aNewAny;
2250 if( !mpImpl->mbIsTransientChildrenDisabled)
2251 {
2252 aOldAny <<= ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >(
2253 static_cast< ::cppu::OWeakObject* >( pItemAcc ));
2254 ImplFireAccessibleEvent (::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldAny, aNewAny );
2255 }
2256 else
2257 {
2258 aOldAny <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED;
2259 pItemAcc->FireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );
2260 }
2261 }
2262 }
2263 }
2264
2265 // focus event (select)
2266 const sal_uInt16 nPos = GetItemPos( mnSelItemId );
2267
2268 ValueSetItem* pItem;
2269 if( nPos != VALUESET_ITEM_NOTFOUND )
2270 pItem = mpImpl->mpItemList->GetObject(nPos);
2271 else
2272 pItem = mpNoneItem;
2273
2274 ValueItemAcc* pItemAcc = NULL;
2275 if (pItem != NULL)
2276 pItemAcc = ValueItemAcc::getImplementation(pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ) );
2277
2278 if( pItemAcc )
2279 {
2280 ::com::sun::star::uno::Any aOldAny, aNewAny;
2281 if( !mpImpl->mbIsTransientChildrenDisabled)
2282 {
2283 aNewAny <<= ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface >(
2284 static_cast< ::cppu::OWeakObject* >( pItemAcc ));
2285 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aOldAny, aNewAny );
2286 }
2287 else
2288 {
2289 aNewAny <<= ::com::sun::star::accessibility::AccessibleStateType::FOCUSED;
2290 pItemAcc->FireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::STATE_CHANGED, aOldAny, aNewAny );
2291 }
2292 }
2293
2294 // selection event
2295 ::com::sun::star::uno::Any aOldAny, aNewAny;
2296 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::SELECTION_CHANGED, aOldAny, aNewAny );
2297 }
2298 mpImpl->maHighlightHdl.Call(this);
2299 }
2300 }
2301
2302 // -----------------------------------------------------------------------
2303
SetNoSelection()2304 void ValueSet::SetNoSelection()
2305 {
2306 mbNoSelection = true;
2307 mbHighlight = false;
2308 mbSelection = false;
2309
2310 if ( IsReallyVisible() && IsUpdateMode() )
2311 ImplDraw();
2312 }
2313
2314 // -----------------------------------------------------------------------
2315
SetItemBits(sal_uInt16 nItemId,sal_uInt16 nItemBits)2316 void ValueSet::SetItemBits( sal_uInt16 nItemId, sal_uInt16 nItemBits )
2317 {
2318 sal_uInt16 nPos = GetItemPos( nItemId );
2319
2320 if ( nPos != VALUESET_ITEM_NOTFOUND )
2321 mpImpl->mpItemList->GetObject( nPos )->mnBits = nItemBits;
2322 }
2323
2324 // -----------------------------------------------------------------------
2325
GetItemBits(sal_uInt16 nItemId) const2326 sal_uInt16 ValueSet::GetItemBits( sal_uInt16 nItemId ) const
2327 {
2328 sal_uInt16 nPos = GetItemPos( nItemId );
2329
2330 if ( nPos != VALUESET_ITEM_NOTFOUND )
2331 return mpImpl->mpItemList->GetObject( nPos )->mnBits;
2332 else
2333 return 0;
2334 }
2335
2336 // -----------------------------------------------------------------------
2337
SetItemImage(sal_uInt16 nItemId,const Image & rImage)2338 void ValueSet::SetItemImage( sal_uInt16 nItemId, const Image& rImage )
2339 {
2340 sal_uInt16 nPos = GetItemPos( nItemId );
2341
2342 if ( nPos == VALUESET_ITEM_NOTFOUND )
2343 return;
2344
2345 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos );
2346 pItem->meType = VALUESETITEM_IMAGE;
2347 pItem->maImage = rImage;
2348
2349 if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
2350 {
2351 ImplFormatItem( pItem );
2352 Invalidate( pItem->maRect );
2353 }
2354 else
2355 mbFormat = true;
2356 }
2357
2358 // -----------------------------------------------------------------------
2359
GetItemImage(sal_uInt16 nItemId) const2360 Image ValueSet::GetItemImage( sal_uInt16 nItemId ) const
2361 {
2362 sal_uInt16 nPos = GetItemPos( nItemId );
2363
2364 if ( nPos != VALUESET_ITEM_NOTFOUND )
2365 return mpImpl->mpItemList->GetObject( nPos )->maImage;
2366 else
2367 return Image();
2368 }
2369
2370 // -----------------------------------------------------------------------
2371
SetItemColor(sal_uInt16 nItemId,const Color & rColor)2372 void ValueSet::SetItemColor( sal_uInt16 nItemId, const Color& rColor )
2373 {
2374 sal_uInt16 nPos = GetItemPos( nItemId );
2375
2376 if ( nPos == VALUESET_ITEM_NOTFOUND )
2377 return;
2378
2379 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos );
2380 pItem->meType = VALUESETITEM_COLOR;
2381 pItem->maColor = rColor;
2382
2383 if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
2384 {
2385 ImplFormatItem( pItem );
2386 Invalidate( pItem->maRect );
2387 }
2388 else
2389 mbFormat = true;
2390 }
2391
2392 // -----------------------------------------------------------------------
2393
GetItemColor(sal_uInt16 nItemId) const2394 Color ValueSet::GetItemColor( sal_uInt16 nItemId ) const
2395 {
2396 sal_uInt16 nPos = GetItemPos( nItemId );
2397
2398 if ( nPos != VALUESET_ITEM_NOTFOUND )
2399 return mpImpl->mpItemList->GetObject( nPos )->maColor;
2400 else
2401 return Color();
2402 }
2403
2404 // -----------------------------------------------------------------------
2405
SetItemData(sal_uInt16 nItemId,void * pData)2406 void ValueSet::SetItemData( sal_uInt16 nItemId, void* pData )
2407 {
2408 sal_uInt16 nPos = GetItemPos( nItemId );
2409
2410 if ( nPos == VALUESET_ITEM_NOTFOUND )
2411 return;
2412
2413 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos );
2414 pItem->mpData = pData;
2415
2416 if ( pItem->meType == VALUESETITEM_USERDRAW )
2417 {
2418 if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
2419 {
2420 ImplFormatItem( pItem );
2421 Invalidate( pItem->maRect );
2422 }
2423 else
2424 mbFormat = true;
2425 }
2426 }
2427
2428 // -----------------------------------------------------------------------
2429
GetItemData(sal_uInt16 nItemId) const2430 void* ValueSet::GetItemData( sal_uInt16 nItemId ) const
2431 {
2432 sal_uInt16 nPos = GetItemPos( nItemId );
2433
2434 if ( nPos != VALUESET_ITEM_NOTFOUND )
2435 return mpImpl->mpItemList->GetObject( nPos )->mpData;
2436 else
2437 return NULL;
2438 }
2439
2440 // -----------------------------------------------------------------------
2441
SetItemText(sal_uInt16 nItemId,const XubString & rText)2442 void ValueSet::SetItemText( sal_uInt16 nItemId, const XubString& rText )
2443 {
2444 sal_uInt16 nPos = GetItemPos( nItemId );
2445
2446 if ( nPos == VALUESET_ITEM_NOTFOUND )
2447 return;
2448
2449
2450 ValueSetItem* pItem = mpImpl->mpItemList->GetObject( nPos );
2451
2452 // Remember old and new name for accessibility event.
2453 ::com::sun::star::uno::Any aOldName, aNewName;
2454 ::rtl::OUString sString (pItem->maText);
2455 aOldName <<= sString;
2456 sString = rText;
2457 aNewName <<= sString;
2458
2459 pItem->maText = rText;
2460
2461 if ( !mbFormat && IsReallyVisible() && IsUpdateMode() )
2462 {
2463 sal_uInt16 nTempId = mnSelItemId;
2464
2465 if ( mbHighlight )
2466 nTempId = mnHighItemId;
2467
2468 if ( nTempId == nItemId )
2469 ImplDrawItemText( pItem->maText );
2470 }
2471
2472 if (ImplHasAccessibleListeners())
2473 {
2474 ::com::sun::star::uno::Reference<
2475 ::com::sun::star::accessibility::XAccessible> xAccessible (
2476 pItem->GetAccessible( mpImpl->mbIsTransientChildrenDisabled ) );
2477 static_cast<ValueItemAcc*>(xAccessible.get())->FireAccessibleEvent (
2478 ::com::sun::star::accessibility::AccessibleEventId::NAME_CHANGED,
2479 aOldName, aNewName);
2480 }
2481 }
2482
2483 // -----------------------------------------------------------------------
2484
GetItemText(sal_uInt16 nItemId) const2485 XubString ValueSet::GetItemText( sal_uInt16 nItemId ) const
2486 {
2487 sal_uInt16 nPos = GetItemPos( nItemId );
2488
2489 if ( nPos != VALUESET_ITEM_NOTFOUND )
2490 return mpImpl->mpItemList->GetObject( nPos )->maText;
2491 else
2492 return XubString();
2493 }
2494
2495 // -----------------------------------------------------------------------
2496
SetColor(const Color & rColor)2497 void ValueSet::SetColor( const Color& rColor )
2498 {
2499 maColor = rColor;
2500 mbFormat = true;
2501 if ( IsReallyVisible() && IsUpdateMode() )
2502 ImplDraw();
2503 }
2504
2505 // -----------------------------------------------------------------------
2506
SetExtraSpacing(sal_uInt16 nNewSpacing)2507 void ValueSet::SetExtraSpacing( sal_uInt16 nNewSpacing )
2508 {
2509 if ( GetStyle() & WB_ITEMBORDER )
2510 {
2511 mnSpacing = nNewSpacing;
2512
2513 mbFormat = true;
2514 if ( IsReallyVisible() && IsUpdateMode() )
2515 Invalidate();
2516 }
2517 }
2518
2519 // -----------------------------------------------------------------------
2520
StartSelection()2521 void ValueSet::StartSelection()
2522 {
2523 mnOldItemId = mnSelItemId;
2524 mbHighlight = true;
2525 mbSelection = true;
2526 mnHighItemId = mnSelItemId;
2527 }
2528
2529 // -----------------------------------------------------------------------
2530
EndSelection()2531 void ValueSet::EndSelection()
2532 {
2533 if ( mbHighlight )
2534 {
2535 if ( IsTracking() )
2536 EndTracking( ENDTRACK_CANCEL );
2537
2538 ImplHighlightItem( mnSelItemId );
2539 mbHighlight = false;
2540 }
2541 mbSelection = false;
2542 }
2543
2544 // -----------------------------------------------------------------------
2545
StartDrag(const CommandEvent & rCEvt,Region & rRegion)2546 sal_Bool ValueSet::StartDrag( const CommandEvent& rCEvt, Region& rRegion )
2547 {
2548 if ( rCEvt.GetCommand() != COMMAND_STARTDRAG )
2549 return sal_False;
2550
2551 // Gegebenenfalls eine vorhandene Aktion abbrechen
2552 EndSelection();
2553
2554 // Testen, ob angeklickte Seite selektiert ist. Falls dies nicht
2555 // der Fall ist, setzen wir ihn als aktuellen Eintrag. Falls Drag and
2556 // Drop auch mal ueber Tastatur ausgeloest werden kann, testen wir
2557 // dies nur bei einer Mausaktion.
2558 sal_uInt16 nSelId;
2559 if ( rCEvt.IsMouseEvent() )
2560 nSelId = GetItemId( rCEvt.GetMousePosPixel() );
2561 else
2562 nSelId = mnSelItemId;
2563
2564 // Falls kein Eintrag angeklickt wurde, starten wir kein Dragging
2565 if ( !nSelId )
2566 return sal_False;
2567
2568 // Testen, ob Seite selektiertiert ist. Falls nicht, als aktuelle
2569 // Seite setzen und Select rufen.
2570 if ( nSelId != mnSelItemId )
2571 {
2572 SelectItem( nSelId );
2573 Update();
2574 Select();
2575 }
2576
2577 Region aRegion;
2578
2579 // Region zuweisen
2580 rRegion = aRegion;
2581
2582 return sal_True;
2583 }
2584
2585 // -----------------------------------------------------------------------
2586
CalcWindowSizePixel(const Size & rItemSize,sal_uInt16 nDesireCols,sal_uInt16 nDesireLines)2587 Size ValueSet::CalcWindowSizePixel( const Size& rItemSize, sal_uInt16 nDesireCols,
2588 sal_uInt16 nDesireLines )
2589 {
2590 long nCalcCols = (long)nDesireCols;
2591 long nCalcLines = (long)nDesireLines;
2592
2593 if ( !nCalcCols )
2594 {
2595 if ( mnUserCols )
2596 nCalcCols = (long)mnUserCols;
2597 else
2598 nCalcCols = 1;
2599 }
2600
2601 if ( !nCalcLines )
2602 {
2603 nCalcLines = mnVisLines;
2604
2605 if ( mbFormat )
2606 {
2607 if ( mnUserVisLines )
2608 nCalcLines = mnUserVisLines;
2609 else
2610 {
2611 nCalcLines = (long)mpImpl->mpItemList->Count() / nCalcCols;
2612 if ( mpImpl->mpItemList->Count() % nCalcCols )
2613 nCalcLines++;
2614 else if ( !nCalcLines )
2615 nCalcLines = 1;
2616 }
2617 }
2618 }
2619
2620 Size aSize( rItemSize.Width()*nCalcCols, rItemSize.Height()*nCalcLines );
2621 WinBits nStyle = GetStyle();
2622 long nTxtHeight = GetTextHeight();
2623 long nSpace;
2624 long n;
2625
2626 if ( nStyle & WB_ITEMBORDER )
2627 {
2628 if ( nStyle & WB_DOUBLEBORDER )
2629 n = ITEM_OFFSET_DOUBLE;
2630 else
2631 n = ITEM_OFFSET;
2632
2633 aSize.Width() += n*nCalcCols;
2634 aSize.Height() += n*nCalcLines;
2635 }
2636 else
2637 n = 0;
2638
2639 if ( mnSpacing )
2640 {
2641 nSpace = mnSpacing;
2642 aSize.Width() += mnSpacing*(nCalcCols-1);
2643 aSize.Height() += mnSpacing*(nCalcLines-1);
2644 }
2645 else
2646 nSpace = 0;
2647
2648 if ( nStyle & WB_NAMEFIELD )
2649 {
2650 aSize.Height() += nTxtHeight + NAME_OFFSET;
2651 if ( !(nStyle & WB_FLATVALUESET) )
2652 aSize.Height() += NAME_LINE_HEIGHT+NAME_LINE_OFF_Y;
2653 }
2654
2655 if ( nStyle & WB_NONEFIELD )
2656 {
2657 aSize.Height() += nTxtHeight + n + nSpace;
2658 if ( nStyle & WB_RADIOSEL )
2659 aSize.Height() += 8;
2660 }
2661
2662 // Evt. ScrollBar-Breite aufaddieren
2663 aSize.Width() += GetScrollWidth();
2664
2665 return aSize;
2666 }
2667
2668 // -----------------------------------------------------------------------
2669
CalcItemSizePixel(const Size & rItemSize,bool bOut) const2670 Size ValueSet::CalcItemSizePixel( const Size& rItemSize, bool bOut ) const
2671 {
2672 Size aSize = rItemSize;
2673
2674 WinBits nStyle = GetStyle();
2675 if ( nStyle & WB_ITEMBORDER )
2676 {
2677 long n;
2678
2679 if ( nStyle & WB_DOUBLEBORDER )
2680 n = ITEM_OFFSET_DOUBLE;
2681 else
2682 n = ITEM_OFFSET;
2683
2684 if ( bOut )
2685 {
2686 aSize.Width() += n;
2687 aSize.Height() += n;
2688 }
2689 else
2690 {
2691 aSize.Width() -= n;
2692 aSize.Height() -= n;
2693 }
2694 }
2695
2696 return aSize;
2697 }
2698
2699 // -----------------------------------------------------------------------
2700
GetScrollWidth() const2701 long ValueSet::GetScrollWidth() const
2702 {
2703 if ( GetStyle() & WB_VSCROLL )
2704 {
2705 ((ValueSet*)this)->ImplInitScrollBar();
2706 return mpScrBar->GetSizePixel().Width()+SCRBAR_OFFSET;
2707 }
2708 else
2709 return 0;
2710 }
2711
2712 // -----------------------------------------------------------------------
2713
ShowDropPos(const Point & rPos)2714 sal_uInt16 ValueSet::ShowDropPos( const Point& rPos )
2715 {
2716 mbDropPos = true;
2717
2718 // Gegebenenfalls scrollen
2719 ImplScroll( rPos );
2720
2721 // DropPosition ermitteln
2722 sal_uInt16 nPos = ImplGetItem( rPos, sal_True );
2723 if ( nPos == VALUESET_ITEM_NONEITEM )
2724 nPos = 0;
2725 else if ( nPos == VALUESET_ITEM_NOTFOUND )
2726 {
2727 Size aOutSize = GetOutputSizePixel();
2728 if ( GetStyle() & WB_NAMEFIELD )
2729 aOutSize.Height() = mnTextOffset;
2730 if ( (rPos.X() >= 0) && (rPos.X() < aOutSize.Width()) &&
2731 (rPos.Y() >= 0) && (rPos.Y() < aOutSize.Height()) )
2732 nPos = (sal_uInt16)mpImpl->mpItemList->Count();
2733 }
2734 else
2735 {
2736 // Im letzten viertel, dann wird ein Item spaeter eingefuegt
2737 Rectangle aRect = mpImpl->mpItemList->GetObject( nPos )->maRect;
2738 if ( rPos.X() > aRect.Left()+aRect.GetWidth()-(aRect.GetWidth()/4) )
2739 nPos++;
2740 }
2741
2742 if ( nPos != mnDropPos )
2743 {
2744 ImplDrawDropPos( sal_False );
2745 mnDropPos = nPos;
2746 ImplDrawDropPos( sal_True );
2747 }
2748
2749 return mnDropPos;
2750 }
2751
2752 // -----------------------------------------------------------------------
2753
HideDropPos()2754 void ValueSet::HideDropPos()
2755 {
2756 if ( mbDropPos )
2757 {
2758 ImplDrawDropPos( sal_False );
2759 mbDropPos = false;
2760 }
2761 }
2762
2763 // -----------------------------------------------------------------------
2764
IsRTLActive(void)2765 bool ValueSet::IsRTLActive (void)
2766 {
2767 return Application::GetSettings().GetLayoutRTL() && IsRTLEnabled();
2768 }
2769
2770 // -----------------------------------------------------------------------
2771
SetHighlightHdl(const Link & rLink)2772 void ValueSet::SetHighlightHdl( const Link& rLink )
2773 {
2774 mpImpl->maHighlightHdl = rLink;
2775 }
2776
2777 // -----------------------------------------------------------------------
2778
GetHighlightHdl() const2779 const Link& ValueSet::GetHighlightHdl() const
2780 {
2781 return mpImpl->maHighlightHdl;
2782 }
2783
2784 // -----------------------------------------------------------------------
2785
SetEdgeBlending(bool bNew)2786 void ValueSet::SetEdgeBlending(bool bNew)
2787 {
2788 if(mbEdgeBlending != bNew)
2789 {
2790 mbEdgeBlending = bNew;
2791 mbFormat = true;
2792
2793 if(IsReallyVisible() && IsUpdateMode())
2794 {
2795 Invalidate();
2796 }
2797 }
2798 }
2799 //For sending out the focused event on the first focused item when this valueset is first focused.
2800 // MT: Focus notifications changed in DEV300 meanwhile, so this is not used for now.
2801 // Just keeping it here for reference, in case something in out implementation doesn't work as expected...
2802 /*
2803 void ValueSet::SetFocusedItem(sal_Bool bFocused)
2804 {
2805 if( ImplHasAccessibleListeners() )
2806 {
2807 // selection event
2808 ::com::sun::star::uno::Any aSelOldAny, aSelNewAny;
2809 if ( mnSelItemId >= 0)
2810 {
2811 // focus event (select)
2812 sal_uInt16 nPos = GetItemPos( mnSelItemId );
2813
2814 ValueSetItem* pItem;
2815 if ((GetStyle() & WB_NONEFIELD) != 0
2816 && nPos == VALUESET_ITEM_NOTFOUND
2817 && mnSelItemId == 0)
2818 {
2819 // When present the first item is the then allways visible none field.
2820 pItem = ImplGetItem (VALUESET_ITEM_NONEITEM);
2821 }
2822 else
2823 {
2824 if (nPos == VALUESET_ITEM_NOTFOUND)
2825 nPos = 0;
2826 pItem = mpImpl->mpItemList->GetObject(nPos);
2827 }
2828 ValueItemAcc* pItemAcc = NULL;
2829 if (pItem != NULL)
2830 pItemAcc = ValueItemAcc::getImplementation(pItem->GetAccessible(mpImpl->mbIsTransientChildrenDisabled) );
2831 if( pItemAcc )
2832 {
2833 if (bFocused)
2834 aSelNewAny <<= pItem->GetAccessible(mpImpl->mbIsTransientChildrenDisabled);
2835 else
2836 aSelOldAny <<= pItem->GetAccessible(mpImpl->mbIsTransientChildrenDisabled);
2837 }
2838 ImplFireAccessibleEvent( ::com::sun::star::accessibility::AccessibleEventId::ACTIVE_DESCENDANT_CHANGED, aSelOldAny, aSelNewAny );
2839 if (pItemAcc && bFocused)
2840 {
2841 pItemAcc->FireAccessibleEvent(
2842 ::com::sun::star::accessibility::AccessibleEventId::SELECTION_CHANGED,
2843 ::com::sun::star::uno::Any(),::com::sun::star::uno::Any());
2844 }
2845 }
2846 }
2847 }
2848 */
2849 //end
2850
2851
2852 // -----------------------------------------------------------------------
2853 // eof
2854