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