?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update credits
[LibreOffice.git] / svtools / source / control / headbar.cxx
blob0cf073032f564f2ca206b36ff6dad870c85c2a77
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 <svtools/headbar.hxx>
21 #include <tools/debug.hxx>
22
23 #include <vcl/svapp.hxx>
24 #include <vcl/help.hxx>
25 #include <vcl/image.hxx>
26 #include <vcl/salnativewidgets.hxx>
27 #include <com/sun/star/accessibility/XAccessible.hpp>
28
29 // =======================================================================
30
31 class ImplHeadItem
32 {
33 public:
34 sal_uInt16 mnId;
35 HeaderBarItemBits mnBits;
36 long mnSize;
37 OString maHelpId;
38 Image maImage;
39 XubString maOutText;
40 XubString maText;
41 XubString maHelpText;
42 };
43
44 // =======================================================================
45
46 #define HEAD_ARROWSIZE1 4
47 #define HEAD_ARROWSIZE2 7
48
49 #define HEADERBAR_TEXTOFF 2
50 #define HEADERBAR_ARROWOFF 5
51 #define HEADERBAR_SPLITOFF 3
52
53 #define HEADERBAR_DRAGOUTOFF 15
54
55 #define HEAD_HITTEST_ITEM ((sal_uInt16)0x0001)
56 #define HEAD_HITTEST_DIVIDER ((sal_uInt16)0x0002)
57
58 // =======================================================================
59
60 void HeaderBar::ImplInit( WinBits nWinStyle )
61 {
62 mpItemList = new ImplHeadItemList;
63 mnBorderOff1 = 0;
64 mnBorderOff2 = 0;
65 mnOffset = 0;
66 mnDX = 0;
67 mnDY = 0;
68 mnDragSize = 0;
69 mnStartPos = 0;
70 mnDragPos = 0;
71 mnMouseOff = 0;
72 mnCurItemId = 0;
73 mnItemDragPos = HEADERBAR_ITEM_NOTFOUND;
74 mbDrag = sal_False;
75 mbItemDrag = sal_False;
76 mbOutDrag = sal_False;
77 mbItemMode = sal_False;
78
79 // StyleBits auswerten
80 if ( nWinStyle & WB_DRAG )
81 mbDragable = sal_True;
82 else
83 mbDragable = sal_False;
84 if ( nWinStyle & WB_BUTTONSTYLE )
85 mbButtonStyle = sal_True;
86 else
87 mbButtonStyle = sal_False;
88 if ( nWinStyle & WB_BORDER )
89 {
90 mnBorderOff1 = 1;
91 mnBorderOff2 = 1;
92 }
93 else
94 {
95 if ( nWinStyle & WB_BOTTOMBORDER )
96 mnBorderOff2 = 1;
97 }
98
99 ImplInitSettings( sal_True, sal_True, sal_True );
100 }
101
102 // -----------------------------------------------------------------------
103
104 HeaderBar::HeaderBar( Window* pParent, WinBits nWinStyle ) :
105 Window( pParent, nWinStyle & WB_3DLOOK )
106 {
107 ImplInit( nWinStyle );
108 SetSizePixel( CalcWindowSizePixel() );
109 }
110
111 // -----------------------------------------------------------------------
112
113 HeaderBar::HeaderBar( Window* pParent, const ResId& rResId ) :
114 Window( pParent, rResId )
115 {
116 ImplInit( rResId.GetWinBits() );
117 }
118
119 // -----------------------------------------------------------------------
120
121 HeaderBar::~HeaderBar()
122 {
123 // Alle Items loeschen
124 for ( size_t i = 0, n = mpItemList->size(); i < n; ++i ) {
125 delete (*mpItemList)[ i ];
126 }
127 mpItemList->clear();
128 delete mpItemList;
129 }
130
131 // -----------------------------------------------------------------------
132
133 void HeaderBar::ImplInitSettings( sal_Bool bFont,
134 sal_Bool bForeground, sal_Bool bBackground )
135 {
136 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
137
138 if ( bFont )
139 {
140 Font aFont;
141 aFont = rStyleSettings.GetToolFont();
142 if ( IsControlFont() )
143 aFont.Merge( GetControlFont() );
144 SetZoomedPointFont( aFont );
145 }
146
147 if ( bForeground || bFont )
148 {
149 Color aColor;
150 if ( IsControlForeground() )
151 aColor = GetControlForeground();
152 else
153 aColor = rStyleSettings.GetButtonTextColor();
154 SetTextColor( aColor );
155 SetTextFillColor();
156 }
157
158 if ( bBackground )
159 {
160 Color aColor;
161 if ( IsControlBackground() )
162 aColor = GetControlBackground();
163 else
164 aColor = rStyleSettings.GetFaceColor();
165 SetBackground( aColor );
166 }
167 }
168
169 // -----------------------------------------------------------------------
170
171 long HeaderBar::ImplGetItemPos( sal_uInt16 nPos ) const
172 {
173 long nX = -mnOffset;
174 for ( size_t i = 0; i < nPos; i++ )
175 nX += (*mpItemList)[ i ]->mnSize;
176 return nX;
177 }
178
179 // -----------------------------------------------------------------------
180
181 Rectangle HeaderBar::ImplGetItemRect( sal_uInt16 nPos ) const
182 {
183 Rectangle aRect( ImplGetItemPos( nPos ), 0, 0, mnDY-1 );
184 aRect.Right() = aRect.Left() + (*mpItemList)[ nPos ]->mnSize - 1;
185 // Gegen Ueberlauf auf einigen Systemen testen
186 if ( aRect.Right() > 16000 )
187 aRect.Right() = 16000;
188 return aRect;
189 }
190
191 // -----------------------------------------------------------------------
192
193 sal_uInt16 HeaderBar::ImplHitTest( const Point& rPos,
194 long& nMouseOff, sal_uInt16& nPos ) const
195 {
196 ImplHeadItem* pItem;
197 size_t nCount = (sal_uInt16)mpItemList->size();
198 sal_Bool bLastFixed = sal_True;
199 long nX = -mnOffset;
200
201 for ( size_t i = 0; i < nCount; i++ )
202 {
203 pItem = (*mpItemList)[ i ];
204
205 if ( rPos.X() < (nX+pItem->mnSize) )
206 {
207 sal_uInt16 nMode;
208
209 if ( !bLastFixed && (rPos.X() < (nX+HEADERBAR_SPLITOFF)) )
210 {
211 nMode = HEAD_HITTEST_DIVIDER;
212 nPos = i-1;
213 nMouseOff = rPos.X()-nX+1;
214 }
215 else
216 {
217 nPos = i;
218
219 if ( !(pItem->mnBits & HIB_FIXED) && (rPos.X() >= (nX+pItem->mnSize-HEADERBAR_SPLITOFF)) )
220 {
221 nMode = HEAD_HITTEST_DIVIDER;
222 nMouseOff = rPos.X()-(nX+pItem->mnSize);
223 }
224 else
225 {
226 nMode = HEAD_HITTEST_ITEM;
227 nMouseOff = rPos.X()-nX;
228 }
229 }
230
231 return nMode;
232 }
233
234 if ( pItem->mnBits & HIB_FIXED )
235 bLastFixed = sal_True;
236 else
237 bLastFixed = sal_False;
238
239 nX += pItem->mnSize;
240 }
241
242 if ( !bLastFixed )
243 {
244 pItem = (*mpItemList)[ nCount-1 ];
245 if ( (pItem->mnSize < 4) && (rPos.X() < (nX+HEADERBAR_SPLITOFF)) )
246 {
247 nPos = nCount-1;
248 nMouseOff = rPos.X()-nX+1;
249 return HEAD_HITTEST_DIVIDER;
250 }
251 }
252
253 return 0;
254 }
255
256 // -----------------------------------------------------------------------
257
258 void HeaderBar::ImplInvertDrag( sal_uInt16 nStartPos, sal_uInt16 nEndPos )
259 {
260 Rectangle aRect1 = ImplGetItemRect( nStartPos );
261 Rectangle aRect2 = ImplGetItemRect( nEndPos );
262 Point aStartPos = aRect1.Center();
263 Point aEndPos = aStartPos;
264 Rectangle aStartRect( aStartPos.X()-2, aStartPos.Y()-2,
265 aStartPos.X()+2, aStartPos.Y()+2 );
266
267 if ( nEndPos > nStartPos )
268 {
269 aStartPos.X() += 3;
270 aEndPos.X() = aRect2.Right()-6;
271 }
272 else
273 {
274 aStartPos.X() -= 3;
275 aEndPos.X() = aRect2.Left()+6;
276 }
277
278 SetRasterOp( ROP_INVERT );
279 DrawRect( aStartRect );
280 DrawLine( aStartPos, aEndPos );
281 if ( nEndPos > nStartPos )
282 {
283 DrawLine( Point( aEndPos.X()+1, aEndPos.Y()-3 ),
284 Point( aEndPos.X()+1, aEndPos.Y()+3 ) );
285 DrawLine( Point( aEndPos.X()+2, aEndPos.Y()-2 ),
286 Point( aEndPos.X()+2, aEndPos.Y()+2 ) );
287 DrawLine( Point( aEndPos.X()+3, aEndPos.Y()-1 ),
288 Point( aEndPos.X()+3, aEndPos.Y()+1 ) );
289 DrawPixel( Point( aEndPos.X()+4, aEndPos.Y() ) );
290 }
291 else
292 {
293 DrawLine( Point( aEndPos.X()-1, aEndPos.Y()-3 ),
294 Point( aEndPos.X()-1, aEndPos.Y()+3 ) );
295 DrawLine( Point( aEndPos.X()-2, aEndPos.Y()-2 ),
296 Point( aEndPos.X()-2, aEndPos.Y()+2 ) );
297 DrawLine( Point( aEndPos.X()-3, aEndPos.Y()-1 ),
298 Point( aEndPos.X()-3, aEndPos.Y()+1 ) );
299 DrawPixel( Point( aEndPos.X()-4, aEndPos.Y() ) );
300 }
301 SetRasterOp( ROP_OVERPAINT );
302 }
303
304 // -----------------------------------------------------------------------
305
306 void HeaderBar::ImplDrawItem( OutputDevice* pDev,
307 sal_uInt16 nPos, sal_Bool bHigh, sal_Bool bDrag,
308 const Rectangle& rItemRect,
309 const Rectangle* pRect,
310 sal_uLong )
311 {
312 Window *const pWin = (pDev->GetOutDevType()==OUTDEV_WINDOW) ? (Window*) pDev : NULL;
313 ImplControlValue aControlValue(0);
314 Rectangle aCtrlRegion;
315 ControlState nState(0);
316
317 Rectangle aRect = rItemRect;
318
319 // Wenn kein Platz, dann brauchen wir auch nichts ausgeben
320 if ( aRect.GetWidth() <= 1 )
321 return;
322
323 // Feststellen, ob Rectangle ueberhaupt sichtbar
324 if ( pRect )
325 {
326 if ( aRect.Right() < pRect->Left() )
327 return;
328 else if ( aRect.Left() > pRect->Right() )
329 return;
330 }
331 else
332 {
333 if ( aRect.Right() < 0 )
334 return;
335 else if ( aRect.Left() > mnDX )
336 return;
337 }
338
339 ImplHeadItem* pItem = (*mpItemList)[ nPos ];
340 HeaderBarItemBits nBits = pItem->mnBits;
341 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
342
343 if( pWin && pWin->IsNativeControlSupported(CTRL_WINDOW_BACKGROUND, PART_ENTIRE_CONTROL) )
344 {
345 aCtrlRegion=aRect;
346 pWin->DrawNativeControl( CTRL_WINDOW_BACKGROUND, PART_ENTIRE_CONTROL,
347 aCtrlRegion, nState, aControlValue,
348 OUString() );
349
350 }
351 else
352 {
353 // Border muss nicht gemalt werden
354 aRect.Top() += mnBorderOff1;
355 aRect.Bottom() -= mnBorderOff2;
356
357 // Hintergrund loeschen
358 if ( !pRect || bDrag )
359 {
360 if ( bDrag )
361 {
362 pDev->SetLineColor();
363 pDev->SetFillColor( rStyleSettings.GetCheckedColor() );
364 pDev->DrawRect( aRect );
365 }
366 else
367 pDev->DrawWallpaper( aRect, GetBackground() );
368 }
369 }
370
371 Color aSelectionTextColor( COL_TRANSPARENT );
372
373 if( pWin && pWin->IsNativeControlSupported(CTRL_LISTHEADER, PART_BUTTON) )
374 {
375 aCtrlRegion=aRect;
376 aControlValue.setTristateVal(BUTTONVALUE_ON);
377 nState|=CTRL_STATE_ENABLED;
378 if(bHigh)
379 nState|=CTRL_STATE_PRESSED;
380 pWin->DrawNativeControl( CTRL_LISTHEADER, PART_BUTTON,
381 aCtrlRegion, nState, aControlValue,
382 OUString() );
383 }
384 else
385 {
386 // Trennlinie malen
387 pDev->SetLineColor( rStyleSettings.GetDarkShadowColor() );
388 pDev->DrawLine( Point( aRect.Right(), aRect.Top() ),
389 Point( aRect.Right(), aRect.Bottom() ) );
390
391 // ButtonStyle malen
392 // avoid 3D borders
393 if( bHigh )
394 DrawSelectionBackground( aRect, 1, sal_True, sal_False, sal_False, &aSelectionTextColor );
395 else if ( !mbButtonStyle || (nBits & HIB_FLAT) )
396 DrawSelectionBackground( aRect, 0, sal_True, sal_False, sal_False, &aSelectionTextColor );
397 }
398
399 // Wenn kein Platz, dann brauchen wir auch nichts ausgeben
400 if ( aRect.GetWidth() < 1 )
401 return;
402
403 // Positionen und Groessen berechnen und Inhalt ausgeben
404 pItem->maOutText = pItem->maText;
405 Size aImageSize = pItem->maImage.GetSizePixel();
406 Size aTxtSize( pDev->GetTextWidth( pItem->maOutText ), 0 );
407 if ( pItem->maOutText.Len() )
408 aTxtSize.Height() = pDev->GetTextHeight();
409 long nArrowWidth = 0;
410 if ( nBits & (HIB_UPARROW | HIB_DOWNARROW) )
411 nArrowWidth = HEAD_ARROWSIZE2+HEADERBAR_ARROWOFF;
412
413 // Wenn kein Platz fuer Image, dann nicht ausgeben
414 long nTestHeight = aImageSize.Height();
415 if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
416 nTestHeight += aTxtSize.Height();
417 if ( (aImageSize.Width() > aRect.GetWidth()) || (nTestHeight > aRect.GetHeight()) )
418 {
419 aImageSize.Width() = 0;
420 aImageSize.Height() = 0;
421 }
422
423 // Text auf entsprechende Laenge kuerzen
424 sal_Bool bLeftText = sal_False;
425 long nMaxTxtWidth = aRect.GetWidth()-(HEADERBAR_TEXTOFF*2)-nArrowWidth;
426 if ( nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE) )
427 nMaxTxtWidth -= aImageSize.Width();
428 long nTxtWidth = aTxtSize.Width();
429 if ( nTxtWidth > nMaxTxtWidth )
430 {
431 bLeftText = sal_True;
432 // 3 == Len of "..."
433 pItem->maOutText.AppendAscii( "..." );
434 do
435 {
436 pItem->maOutText.Erase( pItem->maOutText.Len()-3-1, 1 );
437 nTxtWidth = pDev->GetTextWidth( pItem->maOutText );
438 }
439 while ( (nTxtWidth > nMaxTxtWidth) && (pItem->maOutText.Len() > 3) );
440 if ( pItem->maOutText.Len() == 3 )
441 {
442 nTxtWidth = 0;
443 pItem->maOutText.Erase();
444 }
445 }
446
447 // Text/Imageposition berechnen
448 long nTxtPos;
449 if ( !bLeftText && (nBits & HIB_RIGHT) )
450 {
451 nTxtPos = aRect.Right()-nTxtWidth-HEADERBAR_TEXTOFF;
452 if ( nBits & HIB_RIGHTIMAGE )
453 nTxtPos -= aImageSize.Width();
454 }
455 else if ( !bLeftText && (nBits & HIB_CENTER) )
456 {
457 long nTempWidth = nTxtWidth;
458 if ( nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE) )
459 nTempWidth += aImageSize.Width();
460 nTxtPos = aRect.Left()+(aRect.GetWidth()-nTempWidth)/2;
461 if ( nBits & HIB_LEFTIMAGE )
462 nTxtPos += aImageSize.Width();
463 if ( nArrowWidth )
464 {
465 if ( nTxtPos+nTxtWidth+nArrowWidth >= aRect.Right() )
466 {
467 nTxtPos = aRect.Left()+HEADERBAR_TEXTOFF;
468 if ( nBits & HIB_LEFTIMAGE )
469 nTxtPos += aImageSize.Width();
470 }
471 }
472 }
473 else
474 {
475 nTxtPos = aRect.Left()+HEADERBAR_TEXTOFF;
476 if ( nBits & HIB_LEFTIMAGE )
477 nTxtPos += aImageSize.Width();
478 if ( nBits & HIB_RIGHT )
479 nTxtPos += nArrowWidth;
480 }
481
482 // TextPosition berechnen
483 long nTxtPosY = 0;
484 if ( pItem->maOutText.Len() || (nArrowWidth && aTxtSize.Height()) )
485 {
486 if ( nBits & HIB_TOP )
487 {
488 nTxtPosY = aRect.Top();
489 if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
490 nTxtPosY += aImageSize.Height();
491 }
492 else if ( nBits & HIB_BOTTOM )
493 nTxtPosY = aRect.Bottom()-aTxtSize.Height();
494 else
495 {
496 long nTempHeight = aTxtSize.Height();
497 if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
498 nTempHeight += aImageSize.Height();
499 nTxtPosY = aRect.Top()+((aRect.GetHeight()-nTempHeight)/2);
500 if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
501 nTxtPosY += aImageSize.Height();
502 }
503 }
504
505 // Text ausgebeben
506 if ( pItem->maOutText.Len() )
507 {
508 if( aSelectionTextColor != Color( COL_TRANSPARENT ) )
509 {
510 pDev->Push( PUSH_TEXTCOLOR );
511 pDev->SetTextColor( aSelectionTextColor );
512 }
513 if ( IsEnabled() )
514 pDev->DrawText( Point( nTxtPos, nTxtPosY ), pItem->maOutText );
515 else
516 pDev->DrawCtrlText( Point( nTxtPos, nTxtPosY ), pItem->maOutText, 0, STRING_LEN, TEXT_DRAW_DISABLE );
517 if( aSelectionTextColor != Color( COL_TRANSPARENT ) )
518 pDev->Pop();
519 }
520
521 // Wenn Image vorhanden, Position berechnen und ausgeben
522 long nImagePosY = 0;
523 if ( aImageSize.Width() && aImageSize.Height() )
524 {
525 long nImagePos = nTxtPos;
526 if ( nBits & HIB_LEFTIMAGE )
527 {
528 nImagePos -= aImageSize.Width();
529 if ( nBits & HIB_RIGHT )
530 nImagePos -= nArrowWidth;
531 }
532 else if ( nBits & HIB_RIGHTIMAGE )
533 {
534 nImagePos += nTxtWidth;
535 if ( !(nBits & HIB_RIGHT) )
536 nImagePos += nArrowWidth;
537 }
538 else
539 {
540 if ( nBits & HIB_RIGHT )
541 nImagePos = aRect.Right()-aImageSize.Width();
542 else if ( nBits & HIB_CENTER )
543 nImagePos = aRect.Left()+(aRect.GetWidth()-aImageSize.Width())/2;
544 else
545 nImagePos = aRect.Left()+HEADERBAR_TEXTOFF;
546 }
547
548 if ( nBits & HIB_TOP )
549 nImagePosY = aRect.Top();
550 else if ( nBits & HIB_BOTTOM )
551 {
552 nImagePosY = aRect.Bottom()-aImageSize.Height();
553 if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
554 nImagePosY -= aTxtSize.Height();
555 }
556 else
557 {
558 long nTempHeight = aImageSize.Height();
559 if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) )
560 nTempHeight += aTxtSize.Height();
561 nImagePosY = aRect.Top()+((aRect.GetHeight()-nTempHeight)/2);
562 }
563 if ( nImagePos+aImageSize.Width() <= aRect.Right() )
564 {
565 sal_uInt16 nStyle = 0;
566 if ( !IsEnabled() )
567 nStyle |= IMAGE_DRAW_DISABLE;
568 pDev->DrawImage( Point( nImagePos, nImagePosY ), pItem->maImage, nStyle );
569 }
570 }
571
572 if ( nBits & (HIB_UPARROW | HIB_DOWNARROW) )
573 {
574 long nArrowX = nTxtPos;
575 if ( nBits & HIB_RIGHT )
576 nArrowX -= nArrowWidth;
577 else
578 nArrowX += nTxtWidth+HEADERBAR_ARROWOFF;
579 if ( !(nBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) && !pItem->maText.Len() )
580 {
581 if ( nBits & HIB_RIGHT )
582 nArrowX -= aImageSize.Width();
583 else
584 nArrowX += aImageSize.Width();
585 }
586
587 // Feststellen, ob Platz genug ist, das Item zu malen
588 sal_Bool bDraw = sal_True;
589 if ( nArrowX < aRect.Left()+HEADERBAR_TEXTOFF )
590 bDraw = sal_False;
591 else if ( nArrowX+HEAD_ARROWSIZE2 > aRect.Right() )
592 bDraw = sal_False;
593
594 if ( bDraw )
595 {
596 if( pWin && pWin->IsNativeControlSupported(CTRL_LISTHEADER, PART_ARROW) )
597 {
598 aCtrlRegion=Rectangle(Point(nArrowX,aRect.Top()),Size(nArrowWidth,aRect.GetHeight()));
599 // control value passes 1 if arrow points down, 0 otherwise
600 aControlValue.setNumericVal((nBits&HIB_DOWNARROW)?1:0);
601 nState|=CTRL_STATE_ENABLED;
602 if(bHigh)
603 nState|=CTRL_STATE_PRESSED;
604 pWin->DrawNativeControl( CTRL_LISTHEADER, PART_ARROW,
605 aCtrlRegion, nState, aControlValue,
606 OUString() );
607 }
608 else
609 {
610 long nArrowY;
611 if ( aTxtSize.Height() )
612 nArrowY = nTxtPosY+(aTxtSize.Height()/2);
613 else if ( aImageSize.Width() && aImageSize.Height() )
614 nArrowY = nImagePosY+(aImageSize.Height()/2);
615 else
616 {
617 if ( nBits & HIB_TOP )
618 nArrowY = aRect.Top()+1;
619 else if ( nBits & HIB_BOTTOM )
620 nArrowY = aRect.Bottom()-HEAD_ARROWSIZE2-1;
621 else
622 nArrowY = aRect.Top()+((aRect.GetHeight()-HEAD_ARROWSIZE2)/2);
623 }
624 nArrowY -= HEAD_ARROWSIZE1-1;
625 if ( nBits & HIB_DOWNARROW )
626 {
627 pDev->SetLineColor( rStyleSettings.GetLightColor() );
628 pDev->DrawLine( Point( nArrowX, nArrowY ),
629 Point( nArrowX+HEAD_ARROWSIZE2, nArrowY ) );
630 pDev->DrawLine( Point( nArrowX, nArrowY ),
631 Point( nArrowX+HEAD_ARROWSIZE1, nArrowY+HEAD_ARROWSIZE2 ) );
632 pDev->SetLineColor( rStyleSettings.GetShadowColor() );
633 pDev->DrawLine( Point( nArrowX+HEAD_ARROWSIZE1, nArrowY+HEAD_ARROWSIZE2 ),
634 Point( nArrowX+HEAD_ARROWSIZE2, nArrowY ) );
635 }
636 else
637 {
638 pDev->SetLineColor( rStyleSettings.GetLightColor() );
639 pDev->DrawLine( Point( nArrowX, nArrowY+HEAD_ARROWSIZE2 ),
640 Point( nArrowX+HEAD_ARROWSIZE1, nArrowY ) );
641 pDev->SetLineColor( rStyleSettings.GetShadowColor() );
642 pDev->DrawLine( Point( nArrowX, nArrowY+HEAD_ARROWSIZE2 ),
643 Point( nArrowX+HEAD_ARROWSIZE2, nArrowY+HEAD_ARROWSIZE2 ) );
644 pDev->DrawLine( Point( nArrowX+HEAD_ARROWSIZE2, nArrowY+HEAD_ARROWSIZE2 ),
645 Point( nArrowX+HEAD_ARROWSIZE1, nArrowY ) );
646 }
647 }
648 }
649 }
650
651 // Gegebenenfalls auch UserDraw aufrufen
652 if ( nBits & HIB_USERDRAW )
653 {
654 Region aRegion( aRect );
655 if ( pRect )
656 aRegion.Intersect( *pRect );
657 pDev->SetClipRegion( aRegion );
658 UserDrawEvent aODEvt( pDev, aRect, pItem->mnId );
659 UserDraw( aODEvt );
660 pDev->SetClipRegion();
661 }
662 }
663
664 // -----------------------------------------------------------------------
665
666 void HeaderBar::ImplDrawItem( sal_uInt16 nPos, sal_Bool bHigh, sal_Bool bDrag,
667 const Rectangle* pRect )
668 {
669 Rectangle aRect = ImplGetItemRect( nPos );
670 ImplDrawItem( this, nPos, bHigh, bDrag, aRect, pRect, 0 );
671 }
672
673 // -----------------------------------------------------------------------
674
675 void HeaderBar::ImplUpdate( sal_uInt16 nPos, sal_Bool bEnd, sal_Bool bDirect )
676 {
677 if ( IsVisible() && IsUpdateMode() )
678 {
679 if ( !bDirect )
680 {
681 Rectangle aRect;
682 size_t nItemCount = mpItemList->size();
683 if ( nPos < nItemCount )
684 aRect = ImplGetItemRect( nPos );
685 else
686 {
687 aRect.Bottom() = mnDY-1;
688 if ( nItemCount )
689 aRect.Left() = ImplGetItemRect( nItemCount-1 ).Right();
690 }
691 if ( bEnd )
692 aRect.Right() = mnDX-1;
693 aRect.Top() += mnBorderOff1;
694 aRect.Bottom() -= mnBorderOff2;
695 Invalidate( aRect );
696 }
697 else
698 {
699 for ( size_t i = nPos; i < mpItemList->size(); i++ )
700 ImplDrawItem( i );
701 if ( bEnd )
702 {
703 Rectangle aRect = ImplGetItemRect( (sal_uInt16)mpItemList->size() );
704 aRect.Left() = aRect.Right();
705 aRect.Right() = mnDX-1;
706 if ( aRect.Left() < aRect.Right() )
707 {
708 aRect.Top() += mnBorderOff1;
709 aRect.Bottom() -= mnBorderOff2;
710 Erase( aRect );
711 }
712 }
713 }
714 }
715 }
716
717 // -----------------------------------------------------------------------
718
719 void HeaderBar::ImplStartDrag( const Point& rMousePos, sal_Bool bCommand )
720 {
721 sal_uInt16 nPos;
722 sal_uInt16 nHitTest = ImplHitTest( rMousePos, mnMouseOff, nPos );
723 if ( nHitTest )
724 {
725 mbDrag = sal_False;
726 ImplHeadItem* pItem = (*mpItemList)[ nPos ];
727 if ( nHitTest & HEAD_HITTEST_DIVIDER )
728 mbDrag = sal_True;
729 else
730 {
731 if ( ((pItem->mnBits & HIB_CLICKABLE) && !(pItem->mnBits & HIB_FLAT)) ||
732 (mbDragable && !(pItem->mnBits & HIB_FIXEDPOS)) )
733 {
734 mbItemMode = sal_True;
735 mbDrag = sal_True;
736 if ( bCommand )
737 {
738 if ( mbDragable )
739 mbItemDrag = sal_True;
740 else
741 {
742 mbItemMode = sal_False;
743 mbDrag = sal_False;
744 }
745 }
746 }
747 else
748 {
749 if ( !bCommand )
750 {
751 mnCurItemId = pItem->mnId;
752 Select();
753 mnCurItemId = 0;
754 }
755 }
756 }
757
758 if ( mbDrag )
759 {
760 mbOutDrag = sal_False;
761 mnCurItemId = pItem->mnId;
762 mnItemDragPos = nPos;
763 StartTracking();
764 mnStartPos = rMousePos.X()-mnMouseOff;
765 mnDragPos = mnStartPos;
766 StartDrag();
767 if ( mbItemMode )
768 ImplDrawItem( nPos, sal_True, mbItemDrag );
769 else
770 {
771 Rectangle aSizeRect( mnDragPos, 0, mnDragPos, mnDragSize+mnDY );
772 ShowTracking( aSizeRect, SHOWTRACK_SPLIT );
773 }
774 }
775 else
776 mnMouseOff = 0;
777 }
778 }
779
780 // -----------------------------------------------------------------------
781
782 void HeaderBar::ImplDrag( const Point& rMousePos )
783 {
784 sal_Bool bNewOutDrag;
785 sal_uInt16 nPos = GetItemPos( mnCurItemId );
786
787 mnDragPos = rMousePos.X()-mnMouseOff;
788 if ( mbItemMode )
789 {
790 Rectangle aItemRect = ImplGetItemRect( nPos );
791 if ( aItemRect.IsInside( rMousePos ) )
792 bNewOutDrag = sal_False;
793 else
794 bNewOutDrag = sal_True;
795
796 // Evt. ItemDrag anschalten
797 if ( bNewOutDrag && mbDragable && !mbItemDrag &&
798 !((*mpItemList)[ nPos ]->mnBits & HIB_FIXEDPOS) )
799 {
800 if ( (rMousePos.Y() >= aItemRect.Top()) && (rMousePos.Y() <= aItemRect.Bottom()) )
801 {
802 mbItemDrag = sal_True;
803 ImplDrawItem( nPos, sal_True, mbItemDrag );
804 }
805 }
806
807 sal_uInt16 nOldItemDragPos = mnItemDragPos;
808 if ( mbItemDrag )
809 {
810 if ( (rMousePos.Y() < -HEADERBAR_DRAGOUTOFF) || (rMousePos.Y() > mnDY+HEADERBAR_DRAGOUTOFF) )
811 bNewOutDrag = sal_True;
812 else
813 bNewOutDrag = sal_False;
814
815 if ( bNewOutDrag )
816 mnItemDragPos = HEADERBAR_ITEM_NOTFOUND;
817 else
818 {
819 sal_uInt16 nTempId = GetItemId( Point( rMousePos.X(), 2 ) );
820 if ( nTempId )
821 mnItemDragPos = GetItemPos( nTempId );
822 else
823 {
824 if ( rMousePos.X() <= 0 )
825 mnItemDragPos = 0;
826 else
827 mnItemDragPos = GetItemCount()-1;
828 }
829
830 // Nicht verschiebbare Items aussparen
831 if ( mnItemDragPos < nPos )
832 {
833 while ( ((*mpItemList)[ mnItemDragPos ]->mnBits & HIB_FIXEDPOS) &&
834 (mnItemDragPos < nPos) )
835 mnItemDragPos++;
836 }
837 else if ( mnItemDragPos > nPos )
838 {
839 while ( ((*mpItemList)[ mnItemDragPos ]->mnBits & HIB_FIXEDPOS) &&
840 (mnItemDragPos > nPos) )
841 mnItemDragPos--;
842 }
843 }
844
845 if ( (mnItemDragPos != nOldItemDragPos) &&
846 (nOldItemDragPos != nPos) &&
847 (nOldItemDragPos != HEADERBAR_ITEM_NOTFOUND) )
848 {
849 ImplInvertDrag( nPos, nOldItemDragPos );
850 ImplDrawItem( nOldItemDragPos );
851 }
852 }
853
854 if ( bNewOutDrag != mbOutDrag )
855 ImplDrawItem( nPos, !bNewOutDrag, mbItemDrag );
856
857 if ( mbItemDrag )
858 {
859 if ( (mnItemDragPos != nOldItemDragPos) &&
860 (mnItemDragPos != nPos) &&
861 (mnItemDragPos != HEADERBAR_ITEM_NOTFOUND) )
862 {
863 ImplDrawItem( mnItemDragPos, sal_False, sal_True );
864 ImplInvertDrag( nPos, mnItemDragPos );
865 }
866 }
867
868 mbOutDrag = bNewOutDrag;
869 }
870 else
871 {
872 Rectangle aItemRect = ImplGetItemRect( nPos );
873 if ( mnDragPos < aItemRect.Left() )
874 mnDragPos = aItemRect.Left();
875 if ( (mnDragPos < 0) || (mnDragPos > mnDX-1) )
876 HideTracking();
877 else
878 {
879 Rectangle aSizeRect( mnDragPos, 0, mnDragPos, mnDragSize+mnDY );
880 ShowTracking( aSizeRect, SHOWTRACK_SPLIT );
881 }
882 }
883
884 Drag();
885 }
886
887 // -----------------------------------------------------------------------
888
889 void HeaderBar::ImplEndDrag( sal_Bool bCancel )
890 {
891 HideTracking();
892
893 if ( bCancel || mbOutDrag )
894 {
895 if ( mbItemMode && (!mbOutDrag || mbItemDrag) )
896 {
897 sal_uInt16 nPos = GetItemPos( mnCurItemId );
898 ImplDrawItem( nPos );
899 }
900
901 mnCurItemId = 0;
902 }
903 else
904 {
905 sal_uInt16 nPos = GetItemPos( mnCurItemId );
906 if ( mbItemMode )
907 {
908 if ( mbItemDrag )
909 {
910 Pointer aPointer( POINTER_ARROW );
911 SetPointer( aPointer );
912 if ( (mnItemDragPos != nPos) &&
913 (mnItemDragPos != HEADERBAR_ITEM_NOTFOUND) )
914 {
915 ImplInvertDrag( nPos, mnItemDragPos );
916 MoveItem( mnCurItemId, mnItemDragPos );
917 }
918 else
919 ImplDrawItem( nPos );
920 }
921 else
922 {
923 Select();
924 ImplUpdate( nPos );
925 }
926 }
927 else
928 {
929 long nDelta = mnDragPos - mnStartPos;
930 if ( nDelta )
931 {
932 ImplHeadItem* pItem = (*mpItemList)[ nPos ];
933 pItem->mnSize += nDelta;
934 ImplUpdate( nPos, sal_True );
935 }
936 }
937 }
938
939 mbDrag = sal_False;
940 EndDrag();
941 mnCurItemId = 0;
942 mnItemDragPos = HEADERBAR_ITEM_NOTFOUND;
943 mbOutDrag = sal_False;
944 mbItemMode = sal_False;
945 mbItemDrag = sal_False;
946 }
947
948 // -----------------------------------------------------------------------
949
950 void HeaderBar::MouseButtonDown( const MouseEvent& rMEvt )
951 {
952 if ( rMEvt.IsLeft() )
953 {
954 if ( rMEvt.GetClicks() == 2 )
955 {
956 long nTemp;
957 sal_uInt16 nPos;
958 sal_uInt16 nHitTest = ImplHitTest( rMEvt.GetPosPixel(), nTemp, nPos );
959 if ( nHitTest )
960 {
961 ImplHeadItem* pItem = (*mpItemList)[ nPos ];
962 if ( nHitTest & HEAD_HITTEST_DIVIDER )
963 mbItemMode = sal_False;
964 else
965 mbItemMode = sal_True;
966 mnCurItemId = pItem->mnId;
967 DoubleClick();
968 mbItemMode = sal_False;
969 mnCurItemId = 0;
970 }
971 }
972 else
973 ImplStartDrag( rMEvt.GetPosPixel(), sal_False );
974 }
975 }
976
977 // -----------------------------------------------------------------------
978
979 void HeaderBar::MouseMove( const MouseEvent& rMEvt )
980 {
981 long nTemp1;
982 sal_uInt16 nTemp2;
983 PointerStyle eStyle = POINTER_ARROW;
984 sal_uInt16 nHitTest = ImplHitTest( rMEvt.GetPosPixel(), nTemp1, nTemp2 );
985
986 if ( nHitTest & HEAD_HITTEST_DIVIDER )
987 eStyle = POINTER_HSIZEBAR;
988 Pointer aPtr( eStyle );
989 SetPointer( aPtr );
990 }
991
992 // -----------------------------------------------------------------------
993
994 void HeaderBar::Tracking( const TrackingEvent& rTEvt )
995 {
996 Point aMousePos = rTEvt.GetMouseEvent().GetPosPixel();
997
998 if ( rTEvt.IsTrackingEnded() )
999 ImplEndDrag( rTEvt.IsTrackingCanceled() );
1000 else
1001 ImplDrag( aMousePos );
1002 }
1003
1004 // -----------------------------------------------------------------------
1005
1006 void HeaderBar::Paint( const Rectangle& rRect )
1007 {
1008 if ( mnBorderOff1 || mnBorderOff2 )
1009 {
1010 SetLineColor( GetSettings().GetStyleSettings().GetDarkShadowColor() );
1011 if ( mnBorderOff1 )
1012 DrawLine( Point( 0, 0 ), Point( mnDX-1, 0 ) );
1013 if ( mnBorderOff2 )
1014 DrawLine( Point( 0, mnDY-1 ), Point( mnDX-1, mnDY-1 ) );
1015 // #i40393# draw left and right border, if WB_BORDER was set in ImplInit()
1016 if ( mnBorderOff1 && mnBorderOff2 )
1017 {
1018 DrawLine( Point( 0, 0 ), Point( 0, mnDY-1 ) );
1019 DrawLine( Point( mnDX-1, 0 ), Point( mnDX-1, mnDY-1 ) );
1020 }
1021 }
1022
1023 sal_uInt16 nCurItemPos;
1024 if ( mbDrag )
1025 nCurItemPos = GetItemPos( mnCurItemId );
1026 else
1027 nCurItemPos = HEADERBAR_ITEM_NOTFOUND;
1028 sal_uInt16 nItemCount = (sal_uInt16)mpItemList->size();
1029 for ( sal_uInt16 i = 0; i < nItemCount; i++ )
1030 ImplDrawItem( i, (i == nCurItemPos) ? sal_True : sal_False, sal_False, &rRect );
1031 }
1032
1033 // -----------------------------------------------------------------------
1034
1035 void HeaderBar::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize,
1036 sal_uLong nFlags )
1037 {
1038 Point aPos = pDev->LogicToPixel( rPos );
1039 Size aSize = pDev->LogicToPixel( rSize );
1040 Rectangle aRect( aPos, aSize );
1041 Font aFont = GetDrawPixelFont( pDev );
1042
1043 pDev->Push();
1044 pDev->SetMapMode();
1045 pDev->SetFont( aFont );
1046 if ( nFlags & WINDOW_DRAW_MONO )
1047 pDev->SetTextColor( Color( COL_BLACK ) );
1048 else
1049 pDev->SetTextColor( GetTextColor() );
1050 pDev->SetTextFillColor();
1051
1052 if ( !(nFlags & WINDOW_DRAW_NOBACKGROUND) )
1053 {
1054 pDev->DrawWallpaper( aRect, GetBackground() );
1055 if ( mnBorderOff1 || mnBorderOff2 )
1056 {
1057 pDev->SetLineColor( GetSettings().GetStyleSettings().GetDarkShadowColor() );
1058 if ( mnBorderOff1 )
1059 pDev->DrawLine( aRect.TopLeft(), Point( aRect.Right(), aRect.Top() ) );
1060 if ( mnBorderOff2 )
1061 pDev->DrawLine( Point( aRect.Left(), aRect.Bottom() ), Point( aRect.Right(), aRect.Bottom() ) );
1062 // #i40393# draw left and right border, if WB_BORDER was set in ImplInit()
1063 if ( mnBorderOff1 && mnBorderOff2 )
1064 {
1065 pDev->DrawLine( aRect.TopLeft(), Point( aRect.Left(), aRect.Bottom() ) );
1066 pDev->DrawLine( Point( aRect.Right(), aRect.Top() ), Point( aRect.Right(), aRect.Bottom() ) );
1067 }
1068 }
1069 }
1070
1071 Rectangle aItemRect( aRect );
1072 size_t nItemCount = mpItemList->size();
1073 for ( size_t i = 0; i < nItemCount; i++ )
1074 {
1075 aItemRect.Left() = aRect.Left()+ImplGetItemPos( i );
1076 aItemRect.Right() = aItemRect.Left() + (*mpItemList)[ i ]->mnSize - 1;
1077 // Gegen Ueberlauf auf einigen Systemen testen
1078 if ( aItemRect.Right() > 16000 )
1079 aItemRect.Right() = 16000;
1080 Region aRegion( aRect );
1081 pDev->SetClipRegion( aRegion );
1082 ImplDrawItem( pDev, i, sal_False, sal_False, aItemRect, &aRect, nFlags );
1083 pDev->SetClipRegion();
1084 }
1085
1086 pDev->Pop();
1087 }
1088
1089 // -----------------------------------------------------------------------
1090
1091 void HeaderBar::Resize()
1092 {
1093 Size aSize = GetOutputSizePixel();
1094 if ( IsVisible() && (mnDY != aSize.Height()) )
1095 Invalidate();
1096 mnDX = aSize.Width();
1097 mnDY = aSize.Height();
1098 }
1099
1100 // -----------------------------------------------------------------------
1101
1102 void HeaderBar::Command( const CommandEvent& rCEvt )
1103 {
1104 if ( rCEvt.IsMouseEvent() && (rCEvt.GetCommand() == COMMAND_STARTDRAG) && !mbDrag )
1105 {
1106 ImplStartDrag( rCEvt.GetMousePosPixel(), sal_True );
1107 return;
1108 }
1109
1110 Window::Command( rCEvt );
1111 }
1112
1113 // -----------------------------------------------------------------------
1114
1115 void HeaderBar::RequestHelp( const HelpEvent& rHEvt )
1116 {
1117 sal_uInt16 nItemId = GetItemId( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ) );
1118 if ( nItemId )
1119 {
1120 if ( rHEvt.GetMode() & (HELPMODE_QUICK | HELPMODE_BALLOON) )
1121 {
1122 Rectangle aItemRect = GetItemRect( nItemId );
1123 Point aPt = OutputToScreenPixel( aItemRect.TopLeft() );
1124 aItemRect.Left() = aPt.X();
1125 aItemRect.Top() = aPt.Y();
1126 aPt = OutputToScreenPixel( aItemRect.BottomRight() );
1127 aItemRect.Right() = aPt.X();
1128 aItemRect.Bottom() = aPt.Y();
1129
1130 XubString aStr = GetHelpText( nItemId );
1131 if ( !aStr.Len() || !(rHEvt.GetMode() & HELPMODE_BALLOON) )
1132 {
1133 ImplHeadItem* pItem = (*mpItemList)[ GetItemPos( nItemId ) ];
1134 // Wir zeigen die Quick-Hilfe nur an, wenn Text nicht
1135 // vollstaendig sichtbar, ansonsten zeigen wir den Hilfetext
1136 // an, wenn das Item keinen Text besitzt
1137 if ( pItem->maOutText != pItem->maText )
1138 aStr = pItem->maText;
1139 else if ( pItem->maText.Len() )
1140 aStr.Erase();
1141 }
1142
1143 if ( aStr.Len() )
1144 {
1145 if ( rHEvt.GetMode() & HELPMODE_BALLOON )
1146 Help::ShowBalloon( this, aItemRect.Center(), aItemRect, aStr );
1147 else
1148 Help::ShowQuickHelp( this, aItemRect, aStr );
1149 return;
1150 }
1151 }
1152 else if ( rHEvt.GetMode() & HELPMODE_EXTENDED )
1153 {
1154 OUString aHelpId( OStringToOUString( GetHelpId( nItemId ), RTL_TEXTENCODING_UTF8 ) );
1155 if ( !aHelpId.isEmpty() )
1156 {
1157 // Wenn eine Hilfe existiert, dann ausloesen
1158 Help* pHelp = Application::GetHelp();
1159 if ( pHelp )
1160 pHelp->Start( aHelpId, this );
1161 return;
1162 }
1163 }
1164 }
1165
1166 Window::RequestHelp( rHEvt );
1167 }
1168
1169 // -----------------------------------------------------------------------
1170
1171 void HeaderBar::StateChanged( StateChangedType nType )
1172 {
1173 Window::StateChanged( nType );
1174
1175 if ( nType == STATE_CHANGE_ENABLE )
1176 Invalidate();
1177 else if ( (nType == STATE_CHANGE_ZOOM) ||
1178 (nType == STATE_CHANGE_CONTROLFONT) )
1179 {
1180 ImplInitSettings( sal_True, sal_False, sal_False );
1181 Invalidate();
1182 }
1183 else if ( nType == STATE_CHANGE_CONTROLFOREGROUND )
1184 {
1185 ImplInitSettings( sal_False, sal_True, sal_False );
1186 Invalidate();
1187 }
1188 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
1189 {
1190 ImplInitSettings( sal_False, sal_False, sal_True );
1191 Invalidate();
1192 }
1193 }
1194
1195 // -----------------------------------------------------------------------
1196
1197 void HeaderBar::DataChanged( const DataChangedEvent& rDCEvt )
1198 {
1199 Window::DataChanged( rDCEvt );
1200
1201 if ( (rDCEvt.GetType() == DATACHANGED_FONTS) ||
1202 (rDCEvt.GetType() == DATACHANGED_FONTSUBSTITUTION) ||
1203 ((rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
1204 (rDCEvt.GetFlags() & SETTINGS_STYLE)) )
1205 {
1206 ImplInitSettings( sal_True, sal_True, sal_True );
1207 Invalidate();
1208 }
1209 }
1210
1211 // -----------------------------------------------------------------------
1212
1213 void HeaderBar::UserDraw( const UserDrawEvent& )
1214 {
1215 }
1216
1217 // -----------------------------------------------------------------------
1218
1219 void HeaderBar::StartDrag()
1220 {
1221 maStartDragHdl.Call( this );
1222 }
1223
1224 // -----------------------------------------------------------------------
1225
1226 void HeaderBar::Drag()
1227 {
1228 maDragHdl.Call( this );
1229 }
1230
1231 // -----------------------------------------------------------------------
1232
1233 void HeaderBar::EndDrag()
1234 {
1235 maEndDragHdl.Call( this );
1236 }
1237
1238 // -----------------------------------------------------------------------
1239
1240 void HeaderBar::Select()
1241 {
1242 maSelectHdl.Call( this );
1243 }
1244
1245 // -----------------------------------------------------------------------
1246
1247 void HeaderBar::DoubleClick()
1248 {
1249 maDoubleClickHdl.Call( this );
1250 }
1251
1252 // -----------------------------------------------------------------------
1253
1254 void HeaderBar::InsertItem( sal_uInt16 nItemId, const XubString& rText,
1255 long nSize, HeaderBarItemBits nBits, sal_uInt16 nPos )
1256 {
1257 DBG_ASSERT( nItemId, "HeaderBar::InsertItem(): ItemId == 0" );
1258 DBG_ASSERT( GetItemPos( nItemId ) == HEADERBAR_ITEM_NOTFOUND,
1259 "HeaderBar::InsertItem(): ItemId already exists" );
1260
1261 // Item anlegen und in die Liste einfuegen
1262 ImplHeadItem* pItem = new ImplHeadItem;
1263 pItem->mnId = nItemId;
1264 pItem->mnBits = nBits;
1265 pItem->mnSize = nSize;
1266 pItem->maText = rText;
1267 if ( nPos < mpItemList->size() ) {
1268 ImplHeadItemList::iterator it = mpItemList->begin();
1269 ::std::advance( it, nPos );
1270 mpItemList->insert( it, pItem );
1271 } else {
1272 mpItemList->push_back( pItem );
1273 }
1274
1275 // Ausgabe updaten
1276 ImplUpdate( nPos, sal_True );
1277 }
1278
1279 // -----------------------------------------------------------------------
1280
1281 void HeaderBar::RemoveItem( sal_uInt16 nItemId )
1282 {
1283 sal_uInt16 nPos = GetItemPos( nItemId );
1284 if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1285 {
1286 if ( nPos < mpItemList->size() ) {
1287 ImplHeadItemList::iterator it = mpItemList->begin();
1288 ::std::advance( it, nPos );
1289 delete *it;
1290 mpItemList->erase( it );
1291 }
1292 }
1293 }
1294
1295 // -----------------------------------------------------------------------
1296
1297 void HeaderBar::MoveItem( sal_uInt16 nItemId, sal_uInt16 nNewPos )
1298 {
1299 sal_uInt16 nPos = GetItemPos( nItemId );
1300 if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1301 {
1302 if ( nPos != nNewPos )
1303 {
1304 ImplHeadItemList::iterator it = mpItemList->begin();
1305 ::std::advance( it, nPos );
1306 ImplHeadItem* pItem = *it;
1307 mpItemList->erase( it );
1308 if ( nNewPos < nPos )
1309 nPos = nNewPos;
1310 it = mpItemList->begin();
1311 ::std::advance( it, nPos );
1312 mpItemList->insert( it, pItem );
1313 }
1314 }
1315 }
1316
1317 // -----------------------------------------------------------------------
1318
1319 void HeaderBar::Clear()
1320 {
1321 // Alle Items loeschen
1322 for ( size_t i = 0, n = mpItemList->size(); i < n; ++i ) {
1323 delete (*mpItemList)[ i ];
1324 }
1325 mpItemList->clear();
1326
1327 ImplUpdate( 0, sal_True );
1328 }
1329
1330 // -----------------------------------------------------------------------
1331
1332 void HeaderBar::SetOffset( long nNewOffset )
1333 {
1334 // Bereich verschieben
1335 Rectangle aRect( 0, mnBorderOff1, mnDX-1, mnDY-mnBorderOff1-mnBorderOff2-1 );
1336 long nDelta = mnOffset-nNewOffset;
1337 mnOffset = nNewOffset;
1338 Scroll( nDelta, 0, aRect );
1339 }
1340
1341 // -----------------------------------------------------------------------
1342
1343 sal_uInt16 HeaderBar::GetItemCount() const
1344 {
1345 return (sal_uInt16)mpItemList->size();
1346 }
1347
1348 // -----------------------------------------------------------------------
1349
1350 sal_uInt16 HeaderBar::GetItemPos( sal_uInt16 nItemId ) const
1351 {
1352 for ( size_t i = 0, n = mpItemList->size(); i < n; ++i ) {
1353 ImplHeadItem* pItem = (*mpItemList)[ i ];
1354 if ( pItem->mnId == nItemId )
1355 return (sal_uInt16)i;
1356 }
1357 return HEADERBAR_ITEM_NOTFOUND;
1358 }
1359
1360 // -----------------------------------------------------------------------
1361
1362 sal_uInt16 HeaderBar::GetItemId( sal_uInt16 nPos ) const
1363 {
1364 ImplHeadItem* pItem = (nPos < mpItemList->size() ) ? (*mpItemList)[ nPos ] : NULL;
1365 if ( pItem )
1366 return pItem->mnId;
1367 else
1368 return 0;
1369 }
1370
1371 // -----------------------------------------------------------------------
1372
1373 sal_uInt16 HeaderBar::GetItemId( const Point& rPos ) const
1374 {
1375 for ( size_t i = 0, n = mpItemList->size(); i < n; ++i ) {
1376 if ( ImplGetItemRect( i ).IsInside( rPos ) ) {
1377 return GetItemId( i );
1378 }
1379 }
1380 return 0;
1381 }
1382
1383 // -----------------------------------------------------------------------
1384
1385 Rectangle HeaderBar::GetItemRect( sal_uInt16 nItemId ) const
1386 {
1387 Rectangle aRect;
1388 sal_uInt16 nPos = GetItemPos( nItemId );
1389 if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1390 aRect = ImplGetItemRect( nPos );
1391 return aRect;
1392 }
1393
1394 // -----------------------------------------------------------------------
1395
1396 void HeaderBar::SetItemSize( sal_uInt16 nItemId, long nNewSize )
1397 {
1398 sal_uInt16 nPos = GetItemPos( nItemId );
1399 if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1400 {
1401 ImplHeadItem* pItem = (*mpItemList)[ nPos ];
1402 if ( pItem->mnSize != nNewSize )
1403 {
1404 pItem->mnSize = nNewSize;
1405 ImplUpdate( nPos, sal_True );
1406 }
1407 }
1408 }
1409
1410 // -----------------------------------------------------------------------
1411
1412 long HeaderBar::GetItemSize( sal_uInt16 nItemId ) const
1413 {
1414 sal_uInt16 nPos = GetItemPos( nItemId );
1415 if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1416 return (*mpItemList)[ nPos ]->mnSize;
1417 else
1418 return 0;
1419 }
1420
1421 // -----------------------------------------------------------------------
1422
1423 void HeaderBar::SetItemBits( sal_uInt16 nItemId, HeaderBarItemBits nNewBits )
1424 {
1425 sal_uInt16 nPos = GetItemPos( nItemId );
1426 if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1427 {
1428 ImplHeadItem* pItem = (*mpItemList)[ nPos ];
1429 if ( pItem->mnBits != nNewBits )
1430 {
1431 pItem->mnBits = nNewBits;
1432 ImplUpdate( nPos );
1433 }
1434 }
1435 }
1436
1437 // -----------------------------------------------------------------------
1438
1439 HeaderBarItemBits HeaderBar::GetItemBits( sal_uInt16 nItemId ) const
1440 {
1441 sal_uInt16 nPos = GetItemPos( nItemId );
1442 if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1443 return (*mpItemList)[ nPos ]->mnBits;
1444 else
1445 return 0;
1446 }
1447
1448 // -----------------------------------------------------------------------
1449
1450 void HeaderBar::SetItemText( sal_uInt16 nItemId, const XubString& rText )
1451 {
1452 sal_uInt16 nPos = GetItemPos( nItemId );
1453 if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1454 {
1455 (*mpItemList)[ nPos ]->maText = rText;
1456 ImplUpdate( nPos );
1457 }
1458 }
1459
1460 // -----------------------------------------------------------------------
1461
1462 XubString HeaderBar::GetItemText( sal_uInt16 nItemId ) const
1463 {
1464 sal_uInt16 nPos = GetItemPos( nItemId );
1465 if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1466 return (*mpItemList)[ nPos ]->maText;
1467 else
1468 return String();
1469 }
1470
1471 // -----------------------------------------------------------------------
1472
1473 XubString HeaderBar::GetHelpText( sal_uInt16 nItemId ) const
1474 {
1475 sal_uInt16 nPos = GetItemPos( nItemId );
1476 if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1477 {
1478 ImplHeadItem* pItem = (*mpItemList)[ nPos ];
1479 if ( !pItem->maHelpText.Len() && !pItem->maHelpId.isEmpty() )
1480 {
1481 Help* pHelp = Application::GetHelp();
1482 if ( pHelp )
1483 pItem->maHelpText = pHelp->GetHelpText( OStringToOUString( pItem->maHelpId, RTL_TEXTENCODING_UTF8 ), this );
1484 }
1485
1486 return pItem->maHelpText;
1487 }
1488 else
1489 return XubString();
1490 }
1491
1492 // -----------------------------------------------------------------------
1493
1494 OString HeaderBar::GetHelpId( sal_uInt16 nItemId ) const
1495 {
1496 sal_uInt16 nPos = GetItemPos( nItemId );
1497 OString aRet;
1498 if ( nPos != HEADERBAR_ITEM_NOTFOUND )
1499 return (*mpItemList)[ nPos ]->maHelpId;
1500 return aRet;
1501 }
1502
1503 // -----------------------------------------------------------------------
1504
1505 Size HeaderBar::CalcWindowSizePixel() const
1506 {
1507 long nMaxImageSize = 0;
1508 Size aSize( 0, GetTextHeight() );
1509
1510 for ( size_t i = 0, n = mpItemList->size(); i < n; ++i )
1511 {
1512 ImplHeadItem* pItem = (*mpItemList)[ i ];
1513 // Image-Groessen beruecksichtigen
1514 long nImageHeight = pItem->maImage.GetSizePixel().Height();
1515 if ( !(pItem->mnBits & (HIB_LEFTIMAGE | HIB_RIGHTIMAGE)) && pItem->maText.Len() )
1516 nImageHeight += aSize.Height();
1517 if ( nImageHeight > nMaxImageSize )
1518 nMaxImageSize = nImageHeight;
1519
1520 // Breite aufaddieren
1521 aSize.Width() += pItem->mnSize;
1522 }
1523
1524 if ( nMaxImageSize > aSize.Height() )
1525 aSize.Height() = nMaxImageSize;
1526
1527 // Border aufaddieren
1528 if ( mbButtonStyle )
1529 aSize.Height() += 4;
1530 else
1531 aSize.Height() += 2;
1532 aSize.Height() += mnBorderOff1+mnBorderOff2;
1533
1534 return aSize;
1535 }
1536
1537 ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > HeaderBar::CreateAccessible()
1538 {
1539 if ( !mxAccessible.is() )
1540 {
1541 if ( maCreateAccessibleHdl.IsSet() )
1542 maCreateAccessibleHdl.Call( this );
1543
1544 if ( !mxAccessible.is() )
1545 mxAccessible = Window::CreateAccessible();
1546 }
1547
1548 return mxAccessible;
1549 }
1550
1551 void HeaderBar::SetAccessible( ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > _xAccessible )
1552 {
1553 mxAccessible = _xAccessible;
1554 }
1555
1556 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE