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 : : #include <comphelper/string.hxx>
31 : : #include <tools/debug.hxx>
32 : : #include <tools/rc.h>
33 : :
34 : : #include <vcl/svapp.hxx>
35 : : #include <vcl/help.hxx>
36 : : #include <vcl/bitmap.hxx>
37 : : #include <vcl/toolbox.hxx>
38 : : #include <vcl/mnemonic.hxx>
39 : : #include <vcl/menu.hxx>
40 : : #include <vcl/unohelp.hxx>
41 : : #include <vcl/ImageListProvider.hxx>
42 : :
43 : : #include <svdata.hxx>
44 : : #include <brdwin.hxx>
45 : : #include <toolbox.h>
46 : :
47 : : #include <unotools/confignode.hxx>
48 : :
49 : : #include <com/sun/star/lang/IllegalArgumentException.hpp>
50 : :
51 : : using namespace vcl;
52 : :
53 : : using ::rtl::OUString;
54 : :
55 : : // =======================================================================
56 : :
57 : : #define TB_SEP_SIZE 8
58 : :
59 : : // -----------------------------------------------------------------------
60 : :
61 : 10254 : ImplToolBoxPrivateData::ImplToolBoxPrivateData() :
62 : : m_pLayoutData( NULL ),
63 : : mpImageListProvider( NULL ),
64 [ + - ][ + - ]: 10254 : meImageListType( vcl::IMAGELISTTYPE_UNKNOWN )
[ + - ][ + - ]
[ + - ]
65 : : {
66 : 10254 : meButtonSize = TOOLBOX_BUTTONSIZE_DONTCARE;
67 [ + - ][ + - ]: 10254 : mpMenu = new PopupMenu();
68 : 10254 : mnEventId = 0;
69 : :
70 : 10254 : maMenuType = TOOLBOX_MENUTYPE_NONE;
71 : 10254 : maMenubuttonItem.maItemSize = Size( TB_MENUBUTTON_SIZE+TB_MENUBUTTON_OFFSET, TB_MENUBUTTON_SIZE+TB_MENUBUTTON_OFFSET );
72 : 10254 : maMenubuttonItem.meState = STATE_NOCHECK;
73 : 10254 : mnMenuButtonWidth = TB_MENUBUTTON_SIZE;
74 : :
75 : :
76 : 10254 : mbIsLocked = sal_False;
77 : 10254 : mbNativeButtons = sal_False;
78 : 10254 : mbIsPaintLocked = sal_False;
79 : 10254 : mbAssumeDocked = sal_False;
80 : 10254 : mbAssumePopupMode = sal_False;
81 : 10254 : mbAssumeFloating = sal_False;
82 : 10254 : mbKeyInputDisabled = sal_False;
83 : 10254 : mbMenubuttonSelected = sal_False;
84 : 10254 : mbPageScroll = sal_False;
85 : 10254 : mbWillUsePopupMode = sal_False;
86 : 10254 : mbDropDownByKeyboard = sal_False;
87 : 10254 : }
88 : :
89 [ + - ][ + - ]: 9977 : ImplToolBoxPrivateData::~ImplToolBoxPrivateData()
[ + - ]
90 : : {
91 [ - + ]: 9977 : if( m_pLayoutData )
92 [ # # ][ # # ]: 0 : delete m_pLayoutData;
93 [ + - ][ + - ]: 9977 : delete mpMenu;
94 : 9977 : }
95 : :
96 : : // -----------------------------------------------------------------------
97 [ + - ][ + - ]: 41175 : ImplToolItem::ImplToolItem()
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
98 : : {
99 : 41175 : mnId = 0;
100 : 41175 : mpWindow = NULL;
101 : 41175 : mpUserData = NULL;
102 : 41175 : meType = TOOLBOXITEM_BUTTON;
103 : 41175 : mnBits = 0;
104 : 41175 : meState = STATE_NOCHECK;
105 : 41175 : mbEnabled = sal_True;
106 : 41175 : mbVisible = sal_True;
107 : 41175 : mbEmptyBtn = sal_True;
108 : 41175 : mbShowWindow = sal_False;
109 : 41175 : mbBreak = sal_False;
110 : 41175 : mnSepSize = TB_SEP_SIZE;
111 : 41175 : mnDropDownArrowWidth = TB_DROPDOWNARROWWIDTH;
112 : 41175 : mnImageAngle = 0;
113 : 41175 : mbMirrorMode = sal_False;
114 : 41175 : mbVisibleText = sal_False;
115 : 41175 : }
116 : :
117 : : // -----------------------------------------------------------------------
118 : :
119 : 4311 : ImplToolItem::ImplToolItem( sal_uInt16 nItemId, const Image& rImage,
120 : : ToolBoxItemBits nItemBits ) :
121 [ + - ][ + - ]: 4311 : maImage( rImage )
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
122 : : {
123 : 4311 : mnId = nItemId;
124 : 4311 : mpWindow = NULL;
125 : 4311 : mpUserData = NULL;
126 : 4311 : meType = TOOLBOXITEM_BUTTON;
127 : 4311 : mnBits = nItemBits;
128 : 4311 : meState = STATE_NOCHECK;
129 : 4311 : mbEnabled = sal_True;
130 : 4311 : mbVisible = sal_True;
131 : 4311 : mbEmptyBtn = sal_False;
132 : 4311 : mbShowWindow = sal_False;
133 : 4311 : mbBreak = sal_False;
134 : 4311 : mnSepSize = TB_SEP_SIZE;
135 : 4311 : mnDropDownArrowWidth = TB_DROPDOWNARROWWIDTH;
136 : 4311 : mnImageAngle = 0;
137 : 4311 : mbMirrorMode = false;
138 : 4311 : mbVisibleText = false;
139 : 4311 : }
140 : :
141 : : // -----------------------------------------------------------------------
142 : :
143 : 72572 : ImplToolItem::ImplToolItem( sal_uInt16 nItemId, const XubString& rText,
144 : : ToolBoxItemBits nItemBits ) :
145 [ + - ][ + - ]: 72572 : maText( rText )
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
146 : : {
147 : 72572 : mnId = nItemId;
148 : 72572 : mpWindow = NULL;
149 : 72572 : mpUserData = NULL;
150 : 72572 : meType = TOOLBOXITEM_BUTTON;
151 : 72572 : mnBits = nItemBits;
152 : 72572 : meState = STATE_NOCHECK;
153 : 72572 : mbEnabled = sal_True;
154 : 72572 : mbVisible = sal_True;
155 : 72572 : mbEmptyBtn = sal_False;
156 : 72572 : mbShowWindow = sal_False;
157 : 72572 : mbBreak = sal_False;
158 : 72572 : mnSepSize = TB_SEP_SIZE;
159 : 72572 : mnDropDownArrowWidth = TB_DROPDOWNARROWWIDTH;
160 : 72572 : mnImageAngle = 0;
161 : 72572 : mbMirrorMode = false;
162 : 72572 : mbVisibleText = false;
163 : 72572 : }
164 : :
165 : : // -----------------------------------------------------------------------
166 : :
167 : 594 : ImplToolItem::ImplToolItem( sal_uInt16 nItemId, const Image& rImage,
168 : : const XubString& rText, ToolBoxItemBits nItemBits ) :
169 : : maImage( rImage ),
170 [ + - ][ + - ]: 594 : maText( rText )
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ]
171 : : {
172 : 594 : mnId = nItemId;
173 : 594 : mpWindow = NULL;
174 : 594 : mpUserData = NULL;
175 : 594 : meType = TOOLBOXITEM_BUTTON;
176 : 594 : mnBits = nItemBits;
177 : 594 : meState = STATE_NOCHECK;
178 : 594 : mbEnabled = sal_True;
179 : 594 : mbVisible = sal_True;
180 : 594 : mbEmptyBtn = sal_False;
181 : 594 : mbShowWindow = sal_False;
182 : 594 : mbBreak = sal_False;
183 : 594 : mnSepSize = TB_SEP_SIZE;
184 : 594 : mnDropDownArrowWidth = TB_DROPDOWNARROWWIDTH;
185 : 594 : mnImageAngle = 0;
186 : 594 : mbMirrorMode = false;
187 : 594 : mbVisibleText = false;
188 : 594 : }
189 : :
190 : : // -----------------------------------------------------------------------
191 : :
192 : 274561 : ImplToolItem::ImplToolItem( const ImplToolItem& rItem ) :
193 : : mpWindow ( rItem.mpWindow ),
194 : : mpUserData ( rItem.mpUserData ),
195 : : maImage ( rItem.maImage ),
196 : : maHighImage ( rItem.maHighImage ),
197 : : mnImageAngle ( rItem.mnImageAngle ),
198 : : mbMirrorMode ( rItem.mbMirrorMode ),
199 : : maText ( rItem.maText ),
200 : : maQuickHelpText ( rItem.maQuickHelpText ),
201 : : maHelpText ( rItem.maHelpText ),
202 : : maCommandStr ( rItem.maCommandStr ),
203 : : maHelpId ( rItem.maHelpId ),
204 : : maRect ( rItem.maRect ),
205 : : maCalcRect ( rItem.maCalcRect ),
206 : : maItemSize ( rItem.maItemSize ),
207 : : mnSepSize ( rItem.mnSepSize ),
208 : : mnDropDownArrowWidth ( rItem.mnDropDownArrowWidth ),
209 : : meType ( rItem.meType ),
210 : : mnBits ( rItem.mnBits ),
211 : : meState ( rItem.meState ),
212 : : mnId ( rItem.mnId ),
213 : : mbEnabled ( rItem.mbEnabled ),
214 : : mbVisible ( rItem.mbVisible ),
215 : : mbEmptyBtn ( rItem.mbEmptyBtn ),
216 : : mbShowWindow ( rItem.mbShowWindow ),
217 : : mbBreak ( rItem.mbBreak ),
218 [ + - ][ + - ]: 274561 : mbVisibleText ( rItem.mbVisibleText )
[ + - ][ + - ]
[ + - ]
219 : : {
220 : 274561 : }
221 : :
222 : : // -----------------------------------------------------------------------
223 : :
224 [ + - ][ + - ]: 392817 : ImplToolItem::~ImplToolItem()
[ + - ][ + - ]
[ + - ]
225 : : {
226 : 392817 : }
227 : :
228 : : // -----------------------------------------------------------------------
229 : :
230 : 354 : ImplToolItem& ImplToolItem::operator=( const ImplToolItem& rItem )
231 : : {
232 : 354 : mpWindow = rItem.mpWindow;
233 : 354 : mpUserData = rItem.mpUserData;
234 : 354 : maImage = rItem.maImage;
235 : 354 : maHighImage = rItem.maHighImage;
236 : 354 : mnImageAngle = rItem.mnImageAngle;
237 : 354 : mbMirrorMode = rItem.mbMirrorMode;
238 : 354 : maText = rItem.maText;
239 : 354 : maQuickHelpText = rItem.maQuickHelpText;
240 : 354 : maHelpText = rItem.maHelpText;
241 : 354 : maCommandStr = rItem.maCommandStr;
242 : 354 : maHelpId = rItem.maHelpId;
243 : 354 : maRect = rItem.maRect;
244 : 354 : maCalcRect = rItem.maCalcRect;
245 : 354 : mnSepSize = rItem.mnSepSize;
246 : 354 : mnDropDownArrowWidth = rItem.mnDropDownArrowWidth;
247 : 354 : maItemSize = rItem.maItemSize;
248 : 354 : mbVisibleText = rItem.mbVisibleText;
249 : 354 : meType = rItem.meType;
250 : 354 : mnBits = rItem.mnBits;
251 : 354 : meState = rItem.meState;
252 : 354 : mnId = rItem.mnId;
253 : 354 : mbEnabled = rItem.mbEnabled;
254 : 354 : mbVisible = rItem.mbVisible;
255 : 354 : mbEmptyBtn = rItem.mbEmptyBtn;
256 : 354 : mbShowWindow = rItem.mbShowWindow;
257 : 354 : mbBreak = rItem.mbBreak;
258 : 354 : return *this;
259 : : }
260 : :
261 : : // -----------------------------------------------------------------------
262 : :
263 : 85527 : Size ImplToolItem::GetSize( sal_Bool bHorz, sal_Bool bCheckMaxWidth, long maxWidth, const Size& rDefaultSize )
264 : : {
265 : 85527 : Size aSize( rDefaultSize ); // the size of 'standard' toolbox items
266 : : // non-standard items are eg windows or buttons with text
267 : :
268 [ + + ][ + + ]: 85527 : if ( (meType == TOOLBOXITEM_BUTTON) || (meType == TOOLBOXITEM_SPACE) )
269 : : {
270 : 63857 : aSize = maItemSize;
271 : :
272 [ + + ][ + - ]: 63857 : if ( mpWindow && bHorz )
273 : : {
274 : : // get size of item window and check if it fits
275 : : // no windows in vertical toolbars (the default is mbShowWindow=sal_False)
276 [ + - ]: 4302 : Size aWinSize = mpWindow->GetSizePixel();
277 [ + + ][ + - ]: 4302 : if ( !bCheckMaxWidth || (aWinSize.Width() <= maxWidth) )
[ + - ]
278 : : {
279 : 4302 : aSize.Width() = aWinSize.Width();
280 : 4302 : aSize.Height() = aWinSize.Height();
281 : 4302 : mbShowWindow = sal_True;
282 : : }
283 : : else
284 : : {
285 [ # # ]: 0 : if ( mbEmptyBtn )
286 : : {
287 : 0 : aSize.Width() = 0;
288 : 4302 : aSize.Height() = 0;
289 : : }
290 : : }
291 : 63857 : }
292 : : }
293 [ + + ]: 21670 : else if ( meType == TOOLBOXITEM_SEPARATOR )
294 : : {
295 [ + - ]: 21529 : if ( bHorz )
296 : : {
297 : 21529 : aSize.Width() = mnSepSize;
298 : 21529 : aSize.Height() = rDefaultSize.Height();
299 : : }
300 : : else
301 : : {
302 : 0 : aSize.Width() = rDefaultSize.Width();
303 : 0 : aSize.Height() = mnSepSize;
304 : : }
305 : : }
306 [ + - ]: 141 : else if ( meType == TOOLBOXITEM_BREAK )
307 : : {
308 : 141 : aSize.Width() = 0;
309 : 141 : aSize.Height() = 0;
310 : : }
311 : :
312 : 85527 : return aSize;
313 : : }
314 : :
315 : : // -----------------------------------------------------------------------
316 : :
317 : 100311 : void ImplToolItem::DetermineButtonDrawStyle( ButtonType eButtonType, sal_Bool& rbImage, sal_Bool& rbText ) const
318 : : {
319 [ - + ]: 100311 : if ( meType != TOOLBOXITEM_BUTTON )
320 : : {
321 : : // no button -> draw nothing
322 : 0 : rbImage = rbText = sal_False;
323 : 100311 : return;
324 : : }
325 : :
326 : : sal_Bool bHasImage;
327 : : sal_Bool bHasText;
328 : :
329 : : // check for image and/or text
330 [ + + ]: 100311 : if ( !(maImage) )
331 : 172 : bHasImage = sal_False;
332 : : else
333 : 100139 : bHasImage = sal_True;
334 [ + + ]: 100311 : if ( !maText.Len() )
335 : 1731 : bHasText = sal_False;
336 : : else
337 : 98580 : bHasText = sal_True;
338 : :
339 : : // prefer images if symbolonly buttons are drawn
340 : : // prefer texts if textonly buttons are dreawn
341 : :
342 [ + - ]: 100311 : if ( eButtonType == BUTTON_SYMBOL ) // drawing icons only
343 : : {
344 [ + + ][ + + ]: 100311 : if( bHasImage || !bHasText )
345 : : {
346 : 100151 : rbImage = sal_True;
347 : 100151 : rbText = sal_False;
348 : : }
349 : : else
350 : : {
351 : 160 : rbImage = sal_False;
352 : 100311 : rbText = sal_True;
353 : : }
354 : : }
355 [ # # ]: 0 : else if ( eButtonType == BUTTON_TEXT ) // drawing text only
356 : : {
357 [ # # ][ # # ]: 0 : if( bHasText || !bHasImage )
358 : : {
359 : 0 : rbImage = sal_False;
360 : 0 : rbText = sal_True;
361 : : }
362 : : else
363 : : {
364 : 0 : rbImage = sal_True;
365 : 0 : rbText = sal_False;
366 : : }
367 : : }
368 : : else // drawing icons and text both
369 : : {
370 : 0 : rbImage = sal_True;
371 : 0 : rbText = sal_True;
372 : : }
373 : : }
374 : :
375 : : // -----------------------------------------------------------------------
376 : :
377 : 20100 : Rectangle ImplToolItem::GetDropDownRect( sal_Bool bHorz ) const
378 : : {
379 : 20100 : Rectangle aRect;
380 [ + - ][ + - ]: 20100 : if( (mnBits & TIB_DROPDOWN) && !maRect.IsEmpty() )
[ + - ]
381 : : {
382 : 20100 : aRect = maRect;
383 [ + + ][ - + ]: 20100 : if( mbVisibleText && !bHorz )
384 : : // item will be rotated -> place dropdown to the bottom
385 : 0 : aRect.Top() = aRect.Bottom() - mnDropDownArrowWidth;
386 : : else
387 : : // place dropdown to the right
388 : 20100 : aRect.Left() = aRect.Right() - mnDropDownArrowWidth;
389 : : }
390 : 20100 : return aRect;
391 : : }
392 : :
393 : : // -----------------------------------------------------------------------
394 : :
395 : 328731 : sal_Bool ImplToolItem::IsClipped() const
396 : : {
397 [ + + ][ + + ]: 328731 : return ( meType == TOOLBOXITEM_BUTTON && mbVisible && maRect.IsEmpty() );
[ + + ]
398 : : }
399 : :
400 : : // -----------------------------------------------------------------------
401 : : // -----------------------------------------------------------------------
402 : :
403 : 157283 : const rtl::OUString ToolBox::ImplConvertMenuString( const XubString& rStr )
404 : : {
405 : 157283 : rtl::OUString aCvtStr( rStr );
406 [ - + ]: 157283 : if ( mbMenuStrings )
407 [ # # ]: 0 : aCvtStr = comphelper::string::stripEnd(aCvtStr, '.');
408 [ + - ][ + - ]: 157283 : aCvtStr = MnemonicGenerator::EraseAllMnemonicChars( aCvtStr );
[ + - ][ + - ]
[ + - ]
409 : 157283 : return aCvtStr;
410 : : }
411 : :
412 : : // -----------------------------------------------------------------------
413 : :
414 : 240747 : void ToolBox::ImplInvalidate( sal_Bool bNewCalc, sal_Bool bFullPaint )
415 : : {
416 : 240747 : ImplUpdateInputEnable();
417 : :
418 [ + + ]: 240747 : if ( bNewCalc )
419 : 189636 : mbCalc = sal_True;
420 : :
421 [ + + ]: 240747 : if ( bFullPaint )
422 : : {
423 : 11096 : mbFormat = sal_True;
424 : :
425 : : // Muss ueberhaupt eine neue Ausgabe erfolgen
426 [ + + ][ + - ]: 11096 : if ( IsReallyVisible() && IsUpdateMode() )
[ + + ]
427 : : {
428 : : Invalidate( Rectangle( mnLeftBorder, mnTopBorder,
429 [ + - ]: 10 : mnDX-mnRightBorder-1, mnDY-mnBottomBorder-1 ) );
430 : 10 : maTimer.Stop();
431 : : }
432 : : }
433 : : else
434 : : {
435 [ + + ]: 229651 : if ( !mbFormat )
436 : : {
437 : 9371 : mbFormat = sal_True;
438 : :
439 : : // Muss ueberhaupt eine neue Ausgabe erfolgen
440 [ + + ][ + - ]: 9371 : if ( IsReallyVisible() && IsUpdateMode() )
[ + + ]
441 : 2900 : maTimer.Start();
442 : : }
443 : : }
444 : :
445 : : // request new layout by layoutmanager
446 : 240747 : ImplCallEventListeners( VCLEVENT_TOOLBOX_FORMATCHANGED );
447 : 240747 : }
448 : :
449 : : // -----------------------------------------------------------------------
450 : :
451 : 32117 : void ToolBox::ImplUpdateItem( sal_uInt16 nIndex )
452 : : {
453 : : // Muss ueberhaupt eine neue Ausgabe erfolgen
454 [ + + ][ + - ]: 32117 : if ( IsReallyVisible() && IsUpdateMode() )
[ + + ]
455 : : {
456 [ + + ]: 23867 : if ( nIndex == 0xFFFF )
457 : : {
458 : : // #i52217# no immediate draw as this might lead to paint problems
459 : : Invalidate( Rectangle( mnLeftBorder, mnTopBorder,
460 [ + - ]: 827 : mnDX-mnRightBorder-1, mnDY-mnBottomBorder-1 ) );
461 : : }
462 : : else
463 : : {
464 [ + + ]: 23040 : if ( !mbFormat )
465 : : {
466 : : // #i52217# no immediate draw as this might lead to paint problems
467 : 22553 : Invalidate( mpData->m_aItems[nIndex].maRect );
468 : : }
469 : : else
470 : 487 : maPaintRect.Union( mpData->m_aItems[nIndex].maRect );
471 : : }
472 : : }
473 : 32117 : }
474 : :
475 : : // -----------------------------------------------------------------------
476 : :
477 : 2 : void ToolBox::Click()
478 : : {
479 : 2 : ImplCallEventListeners( VCLEVENT_TOOLBOX_CLICK );
480 : 2 : maClickHdl.Call( this );
481 : 2 : }
482 : :
483 : : // -----------------------------------------------------------------------
484 : :
485 : 0 : void ToolBox::DoubleClick()
486 : : {
487 : 0 : ImplCallEventListeners( VCLEVENT_TOOLBOX_DOUBLECLICK );
488 : 0 : maDoubleClickHdl.Call( this );
489 : 0 : }
490 : :
491 : : // -----------------------------------------------------------------------
492 : :
493 : 2 : void ToolBox::Activate()
494 : : {
495 : 2 : mnActivateCount++;
496 : 2 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ACTIVATE );
497 : 2 : maActivateHdl.Call( this );
498 : 2 : }
499 : :
500 : : // -----------------------------------------------------------------------
501 : :
502 : 2 : void ToolBox::Deactivate()
503 : : {
504 : 2 : mnActivateCount--;
505 : 2 : ImplCallEventListeners( VCLEVENT_TOOLBOX_DEACTIVATE );
506 : 2 : maDeactivateHdl.Call( this );
507 : 2 : }
508 : :
509 : : // -----------------------------------------------------------------------
510 : :
511 : 0 : void ToolBox::Highlight()
512 : : {
513 : 0 : ImplCallEventListeners( VCLEVENT_TOOLBOX_HIGHLIGHT );
514 : 0 : maHighlightHdl.Call( this );
515 : 0 : }
516 : :
517 : : // -----------------------------------------------------------------------
518 : :
519 : 2 : void ToolBox::Select()
520 : : {
521 [ + - ]: 2 : ImplDelData aDelData;
522 [ + - ]: 2 : ImplAddDel( &aDelData );
523 : :
524 [ + - ]: 2 : ImplCallEventListeners( VCLEVENT_TOOLBOX_SELECT );
525 [ + - ]: 2 : maSelectHdl.Call( this );
526 : :
527 [ - + ]: 2 : if ( aDelData.IsDead() )
528 : 2 : return;
529 [ + - ]: 2 : ImplRemoveDel( &aDelData );
530 : :
531 : : // TODO: GetFloatingWindow in DockingWindow is currently inline, change it to check dockingwrapper
532 [ + - ][ + - ]: 2 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
533 [ + - ][ - + ]: 2 : if( pWrapper && pWrapper->GetFloatingWindow() && pWrapper->GetFloatingWindow()->IsInPopupMode() )
[ # # ][ - + ]
534 [ # # ][ + - ]: 2 : pWrapper->GetFloatingWindow()->EndPopupMode();
[ + - ]
535 : : }
536 : :
537 : : // -----------------------------------------------------------------------
538 : :
539 : 0 : void ToolBox::Customize( const ToolBoxCustomizeEvent& )
540 : : {
541 : 0 : }
542 : :
543 : : // -----------------------------------------------------------------------
544 : :
545 : 0 : void ToolBox::UserDraw( const UserDrawEvent& )
546 : : {
547 : 0 : }
548 : :
549 : : // -----------------------------------------------------------------------
550 : :
551 : 8350 : void ToolBox::InsertItem( const ResId& rResId, sal_uInt16 nPos )
552 : : {
553 : : sal_uLong nObjMask;
554 : 8350 : sal_Bool bImage = sal_False; // Wurde Image gesetzt
555 : :
556 : : // Item anlegen
557 [ + - ]: 8350 : ImplToolItem aItem;
558 : :
559 [ + - ]: 8350 : GetRes( rResId.SetRT( RSC_TOOLBOXITEM ) );
560 [ + - ]: 8350 : nObjMask = ReadLongRes();
561 : :
562 [ + + ]: 8350 : if ( nObjMask & RSC_TOOLBOXITEM_ID )
563 [ + - ]: 6854 : aItem.mnId = sal::static_int_cast<sal_uInt16>(ReadLongRes());
564 : : else
565 : 1496 : aItem.mnId = 1;
566 : :
567 [ + + ]: 8350 : if ( nObjMask & RSC_TOOLBOXITEM_TYPE )
568 [ + - ]: 1496 : aItem.meType = (ToolBoxItemType)ReadLongRes();
569 : :
570 [ - + ]: 8350 : if ( nObjMask & RSC_TOOLBOXITEM_STATUS )
571 [ # # ]: 0 : aItem.mnBits = (ToolBoxItemBits)ReadLongRes();
572 : :
573 [ + + ]: 8350 : if( nObjMask & RSC_TOOLBOXITEM_HELPID )
574 [ + - ]: 6854 : aItem.maHelpId = ReadByteStringRes();
575 : :
576 [ + + ]: 8350 : if ( nObjMask & RSC_TOOLBOXITEM_TEXT )
577 : : {
578 [ + - ][ + - ]: 6854 : aItem.maText = ReadStringRes();
579 [ + - ][ + - ]: 6854 : aItem.maText = ImplConvertMenuString( aItem.maText );
580 : : }
581 [ - + ]: 8350 : if ( nObjMask & RSC_TOOLBOXITEM_HELPTEXT )
582 [ # # ][ # # ]: 0 : aItem.maHelpText = ReadStringRes();
583 : :
584 [ - + ]: 8350 : if ( nObjMask & RSC_TOOLBOXITEM_BITMAP )
585 : : {
586 [ # # ][ # # ]: 0 : Bitmap aBmp = Bitmap( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) );
587 [ # # ][ # # ]: 0 : IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
[ # # ]
588 [ # # ][ # # ]: 0 : aItem.maImage = Image( aBmp, IMAGE_STDBTN_COLOR );
[ # # ]
589 [ # # ]: 0 : bImage = sal_True;
590 : : }
591 [ - + ]: 8350 : if ( nObjMask & RSC_TOOLBOXITEM_IMAGE )
592 : : {
593 [ # # ][ # # ]: 0 : aItem.maImage = Image( ResId( (RSHEADER_TYPE*)GetClassRes(), *rResId.GetResMgr() ) );
[ # # ][ # # ]
594 [ # # ][ # # ]: 0 : IncrementRes( GetObjSizeRes( (RSHEADER_TYPE*)GetClassRes() ) );
[ # # ]
595 : 0 : bImage = sal_True;
596 : : }
597 [ - + ]: 8350 : if ( nObjMask & RSC_TOOLBOXITEM_DISABLE )
598 [ # # ]: 0 : aItem.mbEnabled = !(sal_Bool)ReadShortRes();
599 : :
600 [ - + ]: 8350 : if ( nObjMask & RSC_TOOLBOXITEM_STATE )
601 [ # # ]: 0 : aItem.meState = (TriState)ReadLongRes();
602 : :
603 [ - + ]: 8350 : if ( nObjMask & RSC_TOOLBOXITEM_HIDE )
604 [ # # ]: 0 : aItem.mbVisible = !((sal_Bool)ReadShortRes());
605 : :
606 [ - + ]: 8350 : if ( nObjMask & RSC_TOOLBOXITEM_COMMAND )
607 [ # # ][ # # ]: 0 : aItem.maCommandStr = ReadStringRes();
608 : :
609 : : // Wenn kein Image geladen wurde, versuchen wir das Image aus der
610 : : // Image-Liste zu holen
611 [ + - ][ + - ]: 8350 : if ( !bImage && aItem.mnId )
612 [ + - ][ + - ]: 8350 : aItem.maImage = maImageList.GetImage( aItem.mnId );
[ + - ]
613 : :
614 : : // Wenn es sich um ein ButtonItem handelt, die ID ueberpruefen
615 : : sal_Bool bNewCalc;
616 [ + + ]: 8350 : if ( aItem.meType != TOOLBOXITEM_BUTTON )
617 : : {
618 : 1496 : bNewCalc = sal_False;
619 : 1496 : aItem.mnId = 0;
620 : : }
621 : : else
622 : : {
623 : 6854 : bNewCalc = sal_True;
624 : :
625 : : DBG_ASSERT( aItem.mnId, "ToolBox::InsertItem(): ItemId == 0" );
626 : : DBG_ASSERT( GetItemPos( aItem.mnId ) == TOOLBOX_ITEM_NOTFOUND,
627 : : "ToolBox::InsertItem(): ItemId already exists" );
628 : : }
629 : :
630 : : // Item anlegen und in die Liste einfuegen
631 [ - + ][ # # ]: 8350 : mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), aItem );
[ + - ][ - + ]
[ - + ]
[ # # # # ]
632 [ + - ]: 8350 : mpData->ImplClearLayoutData();
633 : :
634 : : // ToolBox neu brechnen und neu ausgeben
635 [ + - ]: 8350 : ImplInvalidate( bNewCalc );
636 : :
637 : : // Notify
638 [ + - ]: 8350 : sal_uInt16 nNewPos = sal::static_int_cast<sal_uInt16>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
639 [ + - ][ + - ]: 8350 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
640 : 8350 : }
641 : :
642 : : // -----------------------------------------------------------------------
643 : :
644 : 4311 : void ToolBox::InsertItem( sal_uInt16 nItemId, const Image& rImage,
645 : : ToolBoxItemBits nBits, sal_uInt16 nPos )
646 : : {
647 : : DBG_ASSERT( nItemId, "ToolBox::InsertItem(): ItemId == 0" );
648 : : DBG_ASSERT( GetItemPos( nItemId ) == TOOLBOX_ITEM_NOTFOUND,
649 : : "ToolBox::InsertItem(): ItemId already exists" );
650 : :
651 : : // Item anlegen und in die Liste einfuegen
652 [ - + ][ # # ]: 4311 : mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), ImplToolItem( nItemId, rImage, nBits ) );
[ + - ][ - + ]
[ - + ]
[ # # # # ]
653 : 4311 : mpData->ImplClearLayoutData();
654 : :
655 : 4311 : ImplInvalidate( sal_True );
656 : :
657 : : // Notify
658 [ + + ]: 4311 : sal_uInt16 nNewPos = sal::static_int_cast<sal_uInt16>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
659 : 4311 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >(nNewPos ) );
660 : 4311 : }
661 : :
662 : : // -----------------------------------------------------------------------
663 : :
664 : 594 : void ToolBox::InsertItem( sal_uInt16 nItemId, const Image& rImage,
665 : : const XubString& rText,
666 : : ToolBoxItemBits nBits, sal_uInt16 nPos )
667 : : {
668 : : DBG_ASSERT( nItemId, "ToolBox::InsertItem(): ItemId == 0" );
669 : : DBG_ASSERT( GetItemPos( nItemId ) == TOOLBOX_ITEM_NOTFOUND,
670 : : "ToolBox::InsertItem(): ItemId already exists" );
671 : :
672 : : // Item anlegen und in die Liste einfuegen
673 [ + - ][ + - ]: 594 : mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), ImplToolItem( nItemId, rImage, ImplConvertMenuString( rText ), nBits ) );
[ + + ][ + - ]
[ + - ][ + + ]
[ + + ][ + - ]
[ + - ]
[ # # # # ]
674 : 594 : mpData->ImplClearLayoutData();
675 : :
676 : 594 : ImplInvalidate( sal_True );
677 : :
678 : : // Notify
679 [ - + ]: 594 : sal_uInt16 nNewPos = sal::static_int_cast<sal_uInt16>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
680 : 594 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
681 : 594 : }
682 : :
683 : : // -----------------------------------------------------------------------
684 : :
685 : 72572 : void ToolBox::InsertItem( sal_uInt16 nItemId, const XubString& rText,
686 : : ToolBoxItemBits nBits, sal_uInt16 nPos )
687 : : {
688 : : DBG_ASSERT( nItemId, "ToolBox::InsertItem(): ItemId == 0" );
689 : : DBG_ASSERT( GetItemPos( nItemId ) == TOOLBOX_ITEM_NOTFOUND,
690 : : "ToolBox::InsertItem(): ItemId already exists" );
691 : :
692 : : // Item anlegen und in die Liste einfuegen
693 [ + - ][ + - ]: 72572 : mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), ImplToolItem( nItemId, ImplConvertMenuString( rText ), nBits ) );
[ + + ][ + - ]
[ + - ][ + + ]
[ + + ][ + - ]
[ + - ]
[ # # # # ]
694 : 72572 : mpData->ImplClearLayoutData();
695 : :
696 : 72572 : ImplInvalidate( sal_True );
697 : :
698 : : // Notify
699 [ + + ]: 72572 : sal_uInt16 nNewPos = sal::static_int_cast<sal_uInt16>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
700 : 72572 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
701 : 72572 : }
702 : :
703 : : // -----------------------------------------------------------------------
704 : :
705 : 458 : void ToolBox::InsertWindow( sal_uInt16 nItemId, Window* pWindow,
706 : : ToolBoxItemBits nBits, sal_uInt16 nPos )
707 : : {
708 : : DBG_ASSERT( nItemId, "ToolBox::InsertWindow(): ItemId == 0" );
709 : : DBG_ASSERT( GetItemPos( nItemId ) == TOOLBOX_ITEM_NOTFOUND,
710 : : "ToolBox::InsertWindow(): ItemId already exists" );
711 : :
712 : : // Item anlegen und in die Liste einfuegen
713 [ + - ]: 458 : ImplToolItem aItem;
714 : 458 : aItem.mnId = nItemId;
715 : 458 : aItem.meType = TOOLBOXITEM_BUTTON;
716 : 458 : aItem.mnBits = nBits;
717 : 458 : aItem.mpWindow = pWindow;
718 [ - + ][ # # ]: 458 : mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), aItem );
[ + - ][ - + ]
[ - + ]
[ # # # # ]
719 [ + - ]: 458 : mpData->ImplClearLayoutData();
720 : :
721 [ + - ]: 458 : if ( pWindow )
722 [ + - ]: 458 : pWindow->Hide();
723 : :
724 [ + - ]: 458 : ImplInvalidate( sal_True );
725 : :
726 : : // Notify
727 [ - + ]: 458 : sal_uInt16 nNewPos = sal::static_int_cast<sal_uInt16>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
728 [ + - ][ + - ]: 458 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
729 : 458 : }
730 : :
731 : : // -----------------------------------------------------------------------
732 : :
733 : 0 : void ToolBox::InsertSpace( sal_uInt16 nPos )
734 : : {
735 : : // Item anlegen und in die Liste einfuegen
736 [ # # ]: 0 : ImplToolItem aItem;
737 : 0 : aItem.meType = TOOLBOXITEM_SPACE;
738 : 0 : aItem.mbEnabled = sal_False;
739 [ # # ][ # # ]: 0 : mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), aItem );
[ # # ][ # # ]
[ # # ]
[ # # # # ]
740 [ # # ]: 0 : mpData->ImplClearLayoutData();
741 : :
742 [ # # ]: 0 : ImplInvalidate( sal_False );
743 : :
744 : : // Notify
745 [ # # ]: 0 : sal_uInt16 nNewPos = sal::static_int_cast<sal_uInt16>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
746 [ # # ][ # # ]: 0 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
747 : 0 : }
748 : :
749 : : // -----------------------------------------------------------------------
750 : :
751 : 22109 : void ToolBox::InsertSeparator( sal_uInt16 nPos, sal_uInt16 nPixSize )
752 : : {
753 : : // Item anlegen und in die Liste einfuegen
754 [ + - ]: 22109 : ImplToolItem aItem;
755 : 22109 : aItem.meType = TOOLBOXITEM_SEPARATOR;
756 : 22109 : aItem.mbEnabled = sal_False;
757 [ - + ]: 22109 : if ( nPixSize )
758 : 0 : aItem.mnSepSize = nPixSize;
759 [ - + ][ # # ]: 22109 : mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), aItem );
[ + - ][ - + ]
[ - + ]
[ # # # # ]
760 [ + - ]: 22109 : mpData->ImplClearLayoutData();
761 : :
762 [ + - ]: 22109 : ImplInvalidate( sal_False );
763 : :
764 : : // Notify
765 [ + + ]: 22109 : sal_uInt16 nNewPos = sal::static_int_cast<sal_uInt16>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
766 [ + - ][ + - ]: 22109 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
767 : 22109 : }
768 : :
769 : : // -----------------------------------------------------------------------
770 : :
771 : 4 : void ToolBox::InsertBreak( sal_uInt16 nPos )
772 : : {
773 : : // Item anlegen und in die Liste einfuegen
774 [ + - ]: 4 : ImplToolItem aItem;
775 : 4 : aItem.meType = TOOLBOXITEM_BREAK;
776 : 4 : aItem.mbEnabled = sal_False;
777 [ - + ][ # # ]: 4 : mpData->m_aItems.insert( (nPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nPos : mpData->m_aItems.end(), aItem );
[ + - ][ - + ]
[ - + ]
[ # # # # ]
778 [ + - ]: 4 : mpData->ImplClearLayoutData();
779 : :
780 [ + - ]: 4 : ImplInvalidate( sal_False );
781 : :
782 : : // Notify
783 [ + - ]: 4 : sal_uInt16 nNewPos = sal::static_int_cast<sal_uInt16>(( nPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nPos);
784 [ + - ][ + - ]: 4 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos ) );
785 : 4 : }
786 : :
787 : : // -----------------------------------------------------------------------
788 : :
789 : 0 : void ToolBox::RemoveItem( sal_uInt16 nPos )
790 : : {
791 [ # # ]: 0 : if( nPos < mpData->m_aItems.size() )
792 : : {
793 : : sal_Bool bMustCalc;
794 [ # # ]: 0 : if ( mpData->m_aItems[nPos].meType == TOOLBOXITEM_BUTTON )
795 : 0 : bMustCalc = sal_True;
796 : : else
797 : 0 : bMustCalc = sal_False;
798 : :
799 [ # # ]: 0 : if ( mpData->m_aItems[nPos].mpWindow )
800 : 0 : mpData->m_aItems[nPos].mpWindow->Hide();
801 : :
802 : : // PaintRect um das removete Item erweitern
803 : 0 : maPaintRect.Union( mpData->m_aItems[nPos].maRect );
804 : :
805 : : // Absichern gegen das Loeschen im Select-Handler
806 [ # # ]: 0 : if ( mpData->m_aItems[nPos].mnId == mnCurItemId )
807 : 0 : mnCurItemId = 0;
808 [ # # ]: 0 : if ( mpData->m_aItems[nPos].mnId == mnHighItemId )
809 : 0 : mnHighItemId = 0;
810 : :
811 : 0 : ImplInvalidate( bMustCalc );
812 : :
813 [ # # ][ # # ]: 0 : mpData->m_aItems.erase( mpData->m_aItems.begin()+nPos );
814 : 0 : mpData->ImplClearLayoutData();
815 : :
816 : : // Notify
817 : 0 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMREMOVED, reinterpret_cast< void* >( nPos ) );
818 : : }
819 : 0 : }
820 : :
821 : : // -----------------------------------------------------------------------
822 : :
823 : 2118 : void ToolBox::CopyItem( const ToolBox& rToolBox, sal_uInt16 nItemId,
824 : : sal_uInt16 nNewPos )
825 : : {
826 : : DBG_ASSERT( GetItemPos( nItemId ) == TOOLBOX_ITEM_NOTFOUND,
827 : : "ToolBox::CopyItem(): ItemId already exists" );
828 : :
829 : 2118 : sal_uInt16 nPos = rToolBox.GetItemPos( nItemId );
830 : :
831 : : // Existiert Item
832 [ + - ]: 2118 : if ( nPos != TOOLBOX_ITEM_NOTFOUND )
833 : : {
834 : : // ToolBox-Item in der Liste verschieben
835 [ + - ]: 2118 : ImplToolItem aNewItem = rToolBox.mpData->m_aItems[nPos];
836 : : // Bestimme Daten zuruecksetzen
837 : 2118 : aNewItem.mpWindow = NULL;
838 : 2118 : aNewItem.mbShowWindow = sal_False;
839 : :
840 [ - + ][ # # ]: 2118 : mpData->m_aItems.insert( (nNewPos < mpData->m_aItems.size()) ? mpData->m_aItems.begin()+nNewPos : mpData->m_aItems.end(), aNewItem );
[ + - ][ - + ]
[ - + ]
[ # # # # ]
841 [ + - ]: 2118 : mpData->ImplClearLayoutData();
842 : : // ToolBox neu ausgeben
843 [ + - ]: 2118 : ImplInvalidate( sal_False );
844 : :
845 : : // Notify
846 [ + - ]: 2118 : sal_uInt16 nNewPos2 = sal::static_int_cast<sal_uInt16>(( nNewPos == TOOLBOX_APPEND ) ? ( mpData->m_aItems.size() - 1 ) : nNewPos);
847 [ + - ][ + - ]: 2118 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMADDED, reinterpret_cast< void* >( nNewPos2 ) );
848 : : }
849 : 2118 : }
850 : :
851 : : // -----------------------------------------------------------------------
852 : :
853 : 4848 : void ToolBox::Clear()
854 : : {
855 : 4848 : mpData->m_aItems.clear();
856 : 4848 : mpData->ImplClearLayoutData();
857 : :
858 : : // Absichern gegen das Loeschen im Select-Handler
859 : 4848 : mnCurItemId = 0;
860 : 4848 : mnHighItemId = 0;
861 : :
862 : 4848 : ImplInvalidate( sal_True, sal_True );
863 : :
864 : : // Notify
865 : 4848 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ALLITEMSCHANGED );
866 : 4848 : }
867 : :
868 : : // -----------------------------------------------------------------------
869 : :
870 : 3709 : void ToolBox::SetButtonType( ButtonType eNewType )
871 : : {
872 [ - + ]: 3709 : if ( meButtonType != eNewType )
873 : : {
874 : 0 : meButtonType = eNewType;
875 : :
876 : : // Hier besser alles neu ausgeben, da es ansonsten zu Problemen
877 : : // mit den per CopyBits kopierten Bereichen geben kann
878 : 0 : ImplInvalidate( sal_True );
879 : : }
880 : 3709 : }
881 : :
882 : : // -----------------------------------------------------------------------
883 : :
884 : 3709 : void ToolBox::SetToolboxButtonSize( ToolBoxButtonSize eSize )
885 : : {
886 [ + - ]: 3709 : if( mpData->meButtonSize != eSize )
887 : : {
888 : 3709 : mpData->meButtonSize = eSize;
889 : 3709 : mbCalc = sal_True;
890 : 3709 : mbFormat = sal_True;
891 : : }
892 : 3709 : }
893 : :
894 : 33510 : ToolBoxButtonSize ToolBox::GetToolboxButtonSize() const
895 : : {
896 : 33510 : return mpData->meButtonSize;
897 : : }
898 : :
899 : : // -----------------------------------------------------------------------
900 : :
901 : 23347 : const Size& ToolBox::GetDefaultImageSize() const
902 : : {
903 [ + + ][ + - ]: 23347 : static Size aSmallButtonSize( TB_SMALLIMAGESIZE, TB_SMALLIMAGESIZE );
904 : :
905 : : static sal_uLong s_nSymbolsStyle = STYLE_SYMBOLS_DEFAULT;
906 [ + + ][ + - ]: 23347 : static Size aLargeButtonSize( TB_LARGEIMAGESIZE, TB_LARGEIMAGESIZE );
907 : :
908 : 23347 : sal_uLong nSymbolsStyle = Application::GetSettings().GetStyleSettings().GetCurrentSymbolsStyle();
909 [ + + ]: 23347 : if ( s_nSymbolsStyle != nSymbolsStyle )
910 : : {
911 : 111 : s_nSymbolsStyle = nSymbolsStyle;
912 [ - - - + ]: 111 : switch ( nSymbolsStyle )
913 : : {
914 : : case STYLE_SYMBOLS_INDUSTRIAL:
915 : 0 : aLargeButtonSize = Size( TB_LARGEIMAGESIZE_INDUSTRIAL, TB_LARGEIMAGESIZE_INDUSTRIAL );
916 : 0 : break;
917 : : case STYLE_SYMBOLS_CRYSTAL:
918 : 0 : aLargeButtonSize = Size( TB_LARGEIMAGESIZE_CRYSTAL, TB_LARGEIMAGESIZE_CRYSTAL );
919 : 0 : break;
920 : : case STYLE_SYMBOLS_OXYGEN:
921 : 0 : aLargeButtonSize = Size( TB_LARGEIMAGESIZE_OXYGEN, TB_LARGEIMAGESIZE_OXYGEN );
922 : 0 : break;
923 : : default:
924 : 111 : aLargeButtonSize = Size( TB_LARGEIMAGESIZE, TB_LARGEIMAGESIZE );
925 : : }
926 : : }
927 : :
928 [ - + ]: 23347 : return GetToolboxButtonSize() == TOOLBOX_BUTTONSIZE_LARGE ? aLargeButtonSize : aSmallButtonSize;
929 : : }
930 : :
931 : : // -----------------------------------------------------------------------
932 : :
933 : 5827 : void ToolBox::SetAlign( WindowAlign eNewAlign )
934 : : {
935 [ + + ]: 5827 : if ( meAlign != eNewAlign )
936 : : {
937 : 200 : meAlign = eNewAlign;
938 : :
939 [ + - ]: 200 : if ( !ImplIsFloatingMode() )
940 : : {
941 : : // Setzen, ob Items horizontal oder vertikal angeordnet werden sollen
942 [ + - ][ - + ]: 200 : if ( (eNewAlign == WINDOWALIGN_LEFT) || (eNewAlign == WINDOWALIGN_RIGHT) )
943 : 0 : mbHorz = sal_False;
944 : : else
945 : 200 : mbHorz = sal_True;
946 : :
947 : : // Hier alles neu ausgeben, da sich Border auch aendert
948 : 200 : mbCalc = sal_True;
949 : 200 : mbFormat = sal_True;
950 [ - + ][ # # ]: 200 : if ( IsReallyVisible() && IsUpdateMode() )
[ - + ]
951 : 0 : Invalidate();
952 : : }
953 : : }
954 : 5827 : }
955 : :
956 : : // -----------------------------------------------------------------------
957 : :
958 : 4049 : void ToolBox::SetLineCount( sal_uInt16 nNewLines )
959 : : {
960 [ - + ]: 4049 : if ( !nNewLines )
961 : 0 : nNewLines = 1;
962 : :
963 [ + + ]: 4049 : if ( mnLines != nNewLines )
964 : : {
965 : 340 : mnLines = nNewLines;
966 : :
967 : : // Hier besser alles neu ausgeben, da es ansonsten zu Problemen
968 : : // mit den per CopyBits kopierten Bereichen geben kann
969 : 340 : ImplInvalidate( sal_False );
970 : : }
971 : 4049 : }
972 : :
973 : : // -----------------------------------------------------------------------
974 : :
975 : 0 : void ToolBox::SetPageScroll( sal_Bool b )
976 : : {
977 : 0 : mpData->mbPageScroll = b;
978 : 0 : }
979 : :
980 : : // -----------------------------------------------------------------------
981 : :
982 : 483878 : sal_uInt16 ToolBox::GetItemCount() const
983 : : {
984 : 483878 : return (sal_uInt16)mpData->m_aItems.size();
985 : : }
986 : :
987 : : // -----------------------------------------------------------------------
988 : :
989 : 3052 : ToolBoxItemType ToolBox::GetItemType( sal_uInt16 nPos ) const
990 : : {
991 [ + - ]: 3052 : return (nPos < mpData->m_aItems.size()) ? mpData->m_aItems[nPos].meType : TOOLBOXITEM_DONTKNOW;
992 : : }
993 : :
994 : : // -----------------------------------------------------------------------
995 : :
996 : 949219 : sal_uInt16 ToolBox::GetItemPos( sal_uInt16 nItemId ) const
997 : : {
998 : 949219 : int nCount = mpData->m_aItems.size();
999 [ + + ]: 18384743 : for( int nPos = 0; nPos < nCount; nPos++ )
1000 [ + + ]: 18384573 : if( mpData->m_aItems[nPos].mnId == nItemId )
1001 : 949049 : return (sal_uInt16)nPos;
1002 : :
1003 : 949219 : return TOOLBOX_ITEM_NOTFOUND;
1004 : : }
1005 : :
1006 : : // -----------------------------------------------------------------------
1007 : :
1008 : 0 : sal_uInt16 ToolBox::GetItemPos( const Point& rPos ) const
1009 : : {
1010 : : // search the item position on the given point
1011 : 0 : sal_uInt16 nRet = TOOLBOX_ITEM_NOTFOUND;
1012 : 0 : sal_uInt16 nPos = 0;
1013 [ # # ]: 0 : std::vector< ImplToolItem >::const_iterator it = mpData->m_aItems.begin();
1014 [ # # ][ # # ]: 0 : while( it != mpData->m_aItems.end() )
1015 : : {
1016 [ # # ][ # # ]: 0 : if ( it->maRect.IsInside( rPos ) )
1017 : : {
1018 : : // item found -> save position and break
1019 : 0 : nRet = nPos;
1020 : 0 : break;
1021 : : }
1022 : :
1023 : 0 : ++it;
1024 : 0 : ++nPos;
1025 : : }
1026 : :
1027 : 0 : return nRet;
1028 : : }
1029 : :
1030 : : // -----------------------------------------------------------------------
1031 : :
1032 : 473341 : sal_uInt16 ToolBox::GetItemId( sal_uInt16 nPos ) const
1033 : : {
1034 [ + - ]: 473341 : return (nPos < mpData->m_aItems.size()) ? mpData->m_aItems[nPos].mnId : 0;
1035 : : }
1036 : :
1037 : : // -----------------------------------------------------------------------
1038 : :
1039 : 0 : sal_uInt16 ToolBox::GetItemId( const Point& rPos ) const
1040 : : {
1041 : : // Item suchen, das geklickt wurde
1042 [ # # ]: 0 : std::vector< ImplToolItem >::const_iterator it = mpData->m_aItems.begin();
1043 [ # # ][ # # ]: 0 : while( it != mpData->m_aItems.end() )
1044 : : {
1045 : : // Ist es dieses Item
1046 [ # # ][ # # ]: 0 : if ( it->maRect.IsInside( rPos ) )
1047 : : {
1048 [ # # ]: 0 : if ( it->meType == TOOLBOXITEM_BUTTON )
1049 : 0 : return it->mnId;
1050 : : else
1051 : 0 : return 0;
1052 : : }
1053 : :
1054 : 0 : ++it;
1055 : : }
1056 : :
1057 : 0 : return 0;
1058 : : }
1059 : :
1060 : : // -----------------------------------------------------------------------
1061 : :
1062 : 0 : Point ToolBox::ImplGetPopupPosition( const Rectangle& rRect, const Size& rSize ) const
1063 : : {
1064 : 0 : Point aPos;
1065 [ # # ]: 0 : if( !rRect.IsEmpty() )
1066 : : {
1067 [ # # ]: 0 : Rectangle aScreen = GetDesktopRectPixel();
1068 : :
1069 : : // the popup should be positioned so that it will not cover
1070 : : // the item rect and that it fits the desktop
1071 : : // the preferred direction is always towards the center of
1072 : : // the application window
1073 : :
1074 : 0 : Point devPos; // the position in device coordinates for screen comparison
1075 [ # # # # : 0 : switch( meAlign )
# ]
1076 : : {
1077 : : case WINDOWALIGN_TOP:
1078 [ # # ]: 0 : aPos = rRect.BottomLeft();
1079 : 0 : aPos.Y()++;
1080 [ # # ]: 0 : devPos = OutputToAbsoluteScreenPixel( aPos );
1081 [ # # ]: 0 : if( devPos.Y() + rSize.Height() >= aScreen.Bottom() )
1082 : 0 : aPos.Y() = rRect.Top() - rSize.Height();
1083 : 0 : break;
1084 : : case WINDOWALIGN_BOTTOM:
1085 : 0 : aPos = rRect.TopLeft();
1086 : 0 : aPos.Y()--;
1087 [ # # ]: 0 : devPos = OutputToAbsoluteScreenPixel( aPos );
1088 [ # # ]: 0 : if( devPos.Y() - rSize.Height() > aScreen.Top() )
1089 : 0 : aPos.Y() -= rSize.Height();
1090 : : else
1091 : 0 : aPos.Y() = rRect.Bottom();
1092 : 0 : break;
1093 : : case WINDOWALIGN_LEFT:
1094 [ # # ]: 0 : aPos = rRect.TopRight();
1095 : 0 : aPos.X()++;
1096 [ # # ]: 0 : devPos = OutputToAbsoluteScreenPixel( aPos );
1097 [ # # ]: 0 : if( devPos.X() + rSize.Width() >= aScreen.Right() )
1098 : 0 : aPos.X() = rRect.Left() - rSize.Width();
1099 : 0 : break;
1100 : : case WINDOWALIGN_RIGHT:
1101 : 0 : aPos = rRect.TopLeft();
1102 : 0 : aPos.X()--;
1103 [ # # ]: 0 : devPos = OutputToAbsoluteScreenPixel( aPos );
1104 [ # # ]: 0 : if( devPos.X() - rSize.Width() > aScreen.Left() )
1105 : 0 : aPos.X() -= rSize.Width();
1106 : : else
1107 : 0 : aPos.X() = rRect.Right();
1108 : 0 : break;
1109 : : default:
1110 : 0 : break;
1111 : : };
1112 : : }
1113 : 0 : return aPos;
1114 : : }
1115 : :
1116 : :
1117 : 0 : Point ToolBox::GetItemPopupPosition( sal_uInt16 nItemId, const Size& rSize ) const
1118 : : {
1119 [ # # ]: 0 : return ImplGetPopupPosition( GetItemRect( nItemId ), rSize );
1120 : : }
1121 : :
1122 : : // -----------------------------------------------------------------------
1123 : :
1124 : 1817 : Rectangle ToolBox::GetItemRect( sal_uInt16 nItemId ) const
1125 : : {
1126 [ + - ][ - + ]: 1817 : if ( mbCalc || mbFormat )
1127 : 0 : ((ToolBox*)this)->ImplFormat();
1128 : :
1129 : 1817 : sal_uInt16 nPos = GetItemPos( nItemId );
1130 : 1817 : return GetItemPosRect( nPos );
1131 : : }
1132 : :
1133 : : // -----------------------------------------------------------------------
1134 : :
1135 : 1817 : Rectangle ToolBox::GetItemPosRect( sal_uInt16 nPos ) const
1136 : : {
1137 [ + - ][ - + ]: 1817 : if ( mbCalc || mbFormat )
1138 : 0 : ((ToolBox*)this)->ImplFormat();
1139 : :
1140 [ + - ]: 1817 : if ( nPos < mpData->m_aItems.size() )
1141 : 1817 : return mpData->m_aItems[nPos].maRect;
1142 : : else
1143 : 1817 : return Rectangle();
1144 : : }
1145 : :
1146 : : // -----------------------------------------------------------------------
1147 : :
1148 : 2914 : sal_Bool ToolBox::ImplHasExternalMenubutton()
1149 : : {
1150 : : // check if the borderwindow (i.e. the decoration) provides the menu button
1151 : 2914 : sal_Bool bRet = sal_False;
1152 [ - + ]: 2914 : if( ImplIsFloatingMode() )
1153 : : {
1154 : : // custom menu is placed in the decoration
1155 [ # # ]: 0 : ImplBorderWindow *pBorderWin = dynamic_cast<ImplBorderWindow*>( GetWindow( WINDOW_BORDER ) );
1156 [ # # ][ # # ]: 0 : if( pBorderWin && !pBorderWin->GetMenuRect().IsEmpty() )
[ # # ][ # # ]
[ # # ]
[ # # # # ]
1157 : 0 : bRet = sal_True;
1158 : : }
1159 : 2914 : return bRet;
1160 : : }
1161 : : // -----------------------------------------------------------------------
1162 : :
1163 : 149579 : void ToolBox::SetItemBits( sal_uInt16 nItemId, ToolBoxItemBits nBits )
1164 : : {
1165 : 149579 : sal_uInt16 nPos = GetItemPos( nItemId );
1166 : :
1167 [ + - ]: 149579 : if ( nPos < mpData->m_aItems.size() )
1168 : : {
1169 : 149579 : ToolBoxItemBits nOldBits = mpData->m_aItems[nPos].mnBits;
1170 : 149579 : mpData->m_aItems[nPos].mnBits = nBits;
1171 : 149579 : nBits &= TIB_LEFT | TIB_AUTOSIZE | TIB_DROPDOWN;
1172 : 149579 : nOldBits &= TIB_LEFT | TIB_AUTOSIZE | TIB_DROPDOWN;
1173 : : // trigger reformat when the item width has changed (dropdown arrow)
1174 : 149579 : sal_Bool bFormat = (nBits & TIB_DROPDOWN) != (nOldBits & TIB_DROPDOWN);
1175 [ + + ]: 149579 : if ( nBits != nOldBits )
1176 : 6248 : ImplInvalidate( sal_True, bFormat );
1177 : : }
1178 : 149579 : }
1179 : :
1180 : : // -----------------------------------------------------------------------
1181 : :
1182 : 150467 : ToolBoxItemBits ToolBox::GetItemBits( sal_uInt16 nItemId ) const
1183 : : {
1184 : 150467 : ImplToolItem* pItem = ImplGetItem( nItemId );
1185 : :
1186 [ + - ]: 150467 : if ( pItem )
1187 : 150467 : return pItem->mnBits;
1188 : : else
1189 : 150467 : return 0;
1190 : : }
1191 : :
1192 : : // -----------------------------------------------------------------------
1193 : :
1194 : 0 : void ToolBox::SetItemData( sal_uInt16 nItemId, void* pNewData )
1195 : : {
1196 : 0 : sal_uInt16 nPos = GetItemPos( nItemId );
1197 : :
1198 [ # # ]: 0 : if ( nPos < mpData->m_aItems.size() )
1199 : : {
1200 : 0 : mpData->m_aItems[nPos].mpUserData = pNewData;
1201 : 0 : ImplUpdateItem( nPos );
1202 : : }
1203 : 0 : }
1204 : :
1205 : : // -----------------------------------------------------------------------
1206 : :
1207 : 123360 : void* ToolBox::GetItemData( sal_uInt16 nItemId ) const
1208 : : {
1209 : 123360 : ImplToolItem* pItem = ImplGetItem( nItemId );
1210 : :
1211 [ + - ]: 123360 : if ( pItem )
1212 : 123360 : return pItem->mpUserData;
1213 : : else
1214 : 123360 : return NULL;
1215 : : }
1216 : :
1217 : : // -----------------------------------------------------------------------
1218 : :
1219 : 83395 : void ToolBox::SetItemImage( sal_uInt16 nItemId, const Image& rImage )
1220 : : {
1221 : 83395 : sal_uInt16 nPos = GetItemPos( nItemId );
1222 : :
1223 [ + - ]: 83395 : if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1224 : : {
1225 : 83395 : ImplToolItem* pItem = &mpData->m_aItems[nPos];
1226 : : // Nur wenn alles berechnet ist, mehr Aufwand treiben
1227 [ + + ]: 83395 : if ( !mbCalc )
1228 : : {
1229 [ + - ]: 4577 : Size aOldSize = pItem->maImage.GetSizePixel();
1230 [ + - ]: 4577 : pItem->maImage = rImage;
1231 [ + - ][ + + ]: 4577 : if ( aOldSize != pItem->maImage.GetSizePixel() )
1232 [ + - ]: 10 : ImplInvalidate( sal_True );
1233 : : else
1234 [ + - ]: 4577 : ImplUpdateItem( nPos );
1235 : : }
1236 : : else
1237 : 78818 : pItem->maImage = rImage;
1238 : : }
1239 : 83395 : }
1240 : :
1241 : : // -----------------------------------------------------------------------
1242 : :
1243 : 188 : void ToolBox::SetImageList( const ImageList& rImageList )
1244 : : {
1245 : 188 : maImageList = rImageList;
1246 : :
1247 : 188 : sal_uInt16 nCount = (sal_uInt16)mpData->m_aItems.size();
1248 [ + + ]: 1568 : for( sal_uInt16 i = 0; i < nCount; i++ )
1249 : : {
1250 [ + - ]: 1380 : Image aImage;
1251 [ + + ]: 1380 : if ( mpData->m_aItems[i].mnId )
1252 [ + - ][ + - ]: 1210 : aImage = maImageList.GetImage( mpData->m_aItems[i].mnId );
[ + - ]
1253 [ + + ]: 1380 : if( !!aImage )
1254 [ + - ]: 1210 : SetItemImage( mpData->m_aItems[i].mnId, aImage );
1255 [ + - ]: 1380 : }
1256 : 188 : }
1257 : :
1258 : : // -----------------------------------------------------------------------
1259 : :
1260 : 0 : static Image ImplRotImage( const Image& rImage, long nAngle10 )
1261 : : {
1262 [ # # ]: 0 : Image aRet;
1263 [ # # ]: 0 : BitmapEx aRotBitmapEx( rImage.GetBitmapEx() );
1264 : :
1265 [ # # ]: 0 : aRotBitmapEx.Rotate( nAngle10, Color( COL_WHITE ) );
1266 : :
1267 [ # # ][ # # ]: 0 : return Image( aRotBitmapEx );
[ # # ]
1268 : : }
1269 : :
1270 : 26936 : void ToolBox::SetItemImageAngle( sal_uInt16 nItemId, long nAngle10 )
1271 : : {
1272 : 26936 : sal_uInt16 nPos = GetItemPos( nItemId );
1273 : :
1274 [ + - ]: 26936 : if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1275 : : {
1276 : 26936 : ImplToolItem* pItem = &mpData->m_aItems[nPos];
1277 [ + - ]: 26936 : Size aOldSize = pItem->maImage.GetSizePixel();
1278 : :
1279 : 26936 : long nDeltaAngle = (nAngle10 - pItem->mnImageAngle) % 3600;
1280 [ - + ]: 26936 : while( nDeltaAngle < 0 )
1281 : 0 : nDeltaAngle += 3600;
1282 : :
1283 : 26936 : pItem->mnImageAngle = nAngle10;
1284 [ - + ][ # # ]: 26936 : if( nDeltaAngle && !!pItem->maImage )
[ - + ]
1285 : : {
1286 [ # # ][ # # ]: 0 : pItem->maImage = ImplRotImage( pItem->maImage, nDeltaAngle );
[ # # ]
1287 [ # # ]: 0 : if( !!pItem->maHighImage )
1288 [ # # ][ # # ]: 0 : pItem->maHighImage = ImplRotImage( pItem->maHighImage, nDeltaAngle );
[ # # ]
1289 : : }
1290 : :
1291 [ + + ]: 26936 : if ( !mbCalc )
1292 : : {
1293 [ + - ][ - + ]: 7124 : if ( aOldSize != pItem->maImage.GetSizePixel() )
1294 [ # # ]: 0 : ImplInvalidate( sal_True );
1295 : : else
1296 [ + - ]: 26936 : ImplUpdateItem( nPos );
1297 : : }
1298 : : }
1299 : 26936 : }
1300 : :
1301 : : // -----------------------------------------------------------------------
1302 : :
1303 : 0 : static Image ImplMirrorImage( const Image& rImage )
1304 : : {
1305 [ # # ]: 0 : Image aRet;
1306 [ # # ]: 0 : BitmapEx aMirrBitmapEx( rImage.GetBitmapEx() );
1307 : :
1308 [ # # ]: 0 : aMirrBitmapEx.Mirror( BMP_MIRROR_HORZ );
1309 : :
1310 [ # # ][ # # ]: 0 : return Image( aMirrBitmapEx );
[ # # ]
1311 : : }
1312 : :
1313 : 43512 : void ToolBox::SetItemImageMirrorMode( sal_uInt16 nItemId, sal_Bool bMirror )
1314 : : {
1315 : 43512 : sal_uInt16 nPos = GetItemPos( nItemId );
1316 : :
1317 [ + - ]: 43512 : if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1318 : : {
1319 : 43512 : ImplToolItem* pItem = &mpData->m_aItems[nPos];
1320 : :
1321 [ # # ][ + - ]: 43512 : if( ( pItem->mbMirrorMode && ! bMirror ) ||
[ - + ][ - + ]
1322 : 43512 : ( ! pItem->mbMirrorMode && bMirror )
1323 : : )
1324 : : {
1325 : 0 : pItem->mbMirrorMode = bMirror ? true : false;
1326 [ # # ]: 0 : if( !!pItem->maImage )
1327 : : {
1328 [ # # ]: 0 : pItem->maImage = ImplMirrorImage( pItem->maImage );
1329 [ # # ]: 0 : if( !!pItem->maHighImage )
1330 [ # # ]: 0 : pItem->maHighImage = ImplMirrorImage( pItem->maHighImage );
1331 : : }
1332 : :
1333 [ # # ]: 0 : if ( !mbCalc )
1334 : 0 : ImplUpdateItem( nPos );
1335 : : }
1336 : : }
1337 : 43512 : }
1338 : :
1339 : : // -----------------------------------------------------------------------
1340 : :
1341 : 2909 : Image ToolBox::GetItemImage( sal_uInt16 nItemId ) const
1342 : : {
1343 : 2909 : ImplToolItem* pItem = ImplGetItem( nItemId );
1344 : :
1345 [ + - ]: 2909 : if ( pItem )
1346 : 2909 : return pItem->maImage;
1347 : : else
1348 : 2909 : return Image();
1349 : : }
1350 : :
1351 : : // -----------------------------------------------------------------------
1352 : :
1353 : 77263 : void ToolBox::SetItemText( sal_uInt16 nItemId, const XubString& rText )
1354 : : {
1355 : 77263 : sal_uInt16 nPos = GetItemPos( nItemId );
1356 : :
1357 [ + - ]: 77263 : if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1358 : : {
1359 : 77263 : ImplToolItem* pItem = &mpData->m_aItems[nPos];
1360 : : // Nur wenn alles berechnet ist, mehr Aufwand treiben
1361 [ + - - + ]: 82043 : if ( !mbCalc &&
[ - + ][ + + ]
1362 : 4780 : ((meButtonType != BUTTON_SYMBOL) || !pItem->maImage) )
1363 : : {
1364 : 0 : long nOldWidth = GetCtrlTextWidth( pItem->maText );
1365 [ # # ]: 0 : pItem->maText = ImplConvertMenuString( rText );
1366 : 0 : mpData->ImplClearLayoutData();
1367 [ # # ]: 0 : if ( nOldWidth != GetCtrlTextWidth( pItem->maText ) )
1368 : 0 : ImplInvalidate( sal_True );
1369 : : else
1370 : 0 : ImplUpdateItem( nPos );
1371 : : }
1372 : : else
1373 [ + - ]: 77263 : pItem->maText = ImplConvertMenuString( rText );
1374 : :
1375 : : // Notify button changed event to prepare accessibility bridge
1376 : 77263 : ImplCallEventListeners( VCLEVENT_TOOLBOX_BUTTONSTATECHANGED, reinterpret_cast< void* >( nPos ) );
1377 : :
1378 : : // Notify
1379 : 77263 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMTEXTCHANGED, reinterpret_cast< void* >( nPos ) );
1380 : : }
1381 : 77263 : }
1382 : :
1383 : : // -----------------------------------------------------------------------
1384 : :
1385 : 6424 : const XubString& ToolBox::GetItemText( sal_uInt16 nItemId ) const
1386 : : {
1387 : 6424 : ImplToolItem* pItem = ImplGetItem( nItemId );
1388 : :
1389 [ + - ]: 6424 : if ( pItem )
1390 : 6424 : return pItem->maText;
1391 : : else
1392 : 6424 : return ImplGetSVEmptyStr();
1393 : : }
1394 : :
1395 : : // -----------------------------------------------------------------------
1396 : :
1397 : 93741 : void ToolBox::SetItemWindow( sal_uInt16 nItemId, Window* pNewWindow )
1398 : : {
1399 : 93741 : sal_uInt16 nPos = GetItemPos( nItemId );
1400 : :
1401 [ + - ]: 93741 : if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1402 : : {
1403 : 93741 : ImplToolItem* pItem = &mpData->m_aItems[nPos];
1404 : 93741 : pItem->mpWindow = pNewWindow;
1405 [ + + ]: 93741 : if ( pNewWindow )
1406 : 4125 : pNewWindow->Hide();
1407 : 93741 : ImplInvalidate( sal_True );
1408 : 93741 : ImplCallEventListeners( VCLEVENT_TOOLBOX_ITEMWINDOWCHANGED, reinterpret_cast< void* >( nPos ) );
1409 : : }
1410 : 93741 : }
1411 : :
1412 : : // -----------------------------------------------------------------------
1413 : :
1414 : 58417 : Window* ToolBox::GetItemWindow( sal_uInt16 nItemId ) const
1415 : : {
1416 : 58417 : ImplToolItem* pItem = ImplGetItem( nItemId );
1417 : :
1418 [ + - ]: 58417 : if ( pItem )
1419 : 58417 : return pItem->mpWindow;
1420 : : else
1421 : 58417 : return NULL;
1422 : : }
1423 : :
1424 : : // -----------------------------------------------------------------------
1425 : :
1426 : 0 : void ToolBox::StartSelection()
1427 : : {
1428 [ # # ]: 0 : if ( mbDrag )
1429 : 0 : EndSelection();
1430 : :
1431 [ # # ]: 0 : if ( !mbSelection )
1432 : : {
1433 : 0 : mbSelection = sal_True;
1434 : 0 : mnCurPos = TOOLBOX_ITEM_NOTFOUND;
1435 : 0 : mnCurItemId = 0;
1436 : 0 : Activate();
1437 : : }
1438 : 0 : }
1439 : :
1440 : : // -----------------------------------------------------------------------
1441 : :
1442 : 0 : void ToolBox::EndSelection()
1443 : : {
1444 : 0 : mbCommandDrag = sal_False;
1445 : :
1446 [ # # ][ # # ]: 0 : if ( mbDrag || mbSelection )
1447 : : {
1448 : : // Daten zuruecksetzen
1449 : 0 : mbDrag = sal_False;
1450 : 0 : mbSelection = sal_False;
1451 [ # # ]: 0 : if ( mnCurPos != TOOLBOX_ITEM_NOTFOUND )
1452 : 0 : ImplDrawItem( mnCurPos );
1453 : 0 : EndTracking();
1454 : 0 : ReleaseMouse();
1455 : 0 : Deactivate();
1456 : : }
1457 : :
1458 : 0 : mnCurPos = TOOLBOX_ITEM_NOTFOUND;
1459 : 0 : mnCurItemId = 0;
1460 : 0 : mnDownItemId = 0;
1461 : 0 : mnMouseClicks = 0;
1462 : 0 : mnMouseModifier = 0;
1463 : 0 : }
1464 : :
1465 : : // -----------------------------------------------------------------------
1466 : :
1467 : 0 : void ToolBox::SetItemDown( sal_uInt16 nItemId, sal_Bool bDown, sal_Bool bRelease )
1468 : : {
1469 : 0 : sal_uInt16 nPos = GetItemPos( nItemId );
1470 : :
1471 [ # # ]: 0 : if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1472 : : {
1473 [ # # ]: 0 : if ( bDown )
1474 : : {
1475 [ # # ]: 0 : if ( nPos != mnCurPos )
1476 : : {
1477 : 0 : mnCurPos = nPos;
1478 : 0 : ImplDrawItem( mnCurPos, sal_True );
1479 : 0 : Flush();
1480 : : }
1481 : : }
1482 : : else
1483 : : {
1484 [ # # ]: 0 : if ( nPos == mnCurPos )
1485 : : {
1486 : 0 : ImplDrawItem( mnCurPos, sal_False );
1487 : 0 : Flush();
1488 : 0 : mnCurPos = TOOLBOX_ITEM_NOTFOUND;
1489 : : }
1490 : : }
1491 : :
1492 [ # # ]: 0 : if ( bRelease )
1493 : : {
1494 [ # # ][ # # ]: 0 : if ( mbDrag || mbSelection )
1495 : : {
1496 : 0 : mbDrag = sal_False;
1497 : 0 : mbSelection = sal_False;
1498 : 0 : EndTracking();
1499 : 0 : ReleaseMouse();
1500 : 0 : Deactivate();
1501 : : }
1502 : :
1503 : 0 : mnCurItemId = 0;
1504 : 0 : mnDownItemId = 0;
1505 : 0 : mnMouseClicks = 0;
1506 : 0 : mnMouseModifier = 0;
1507 : : }
1508 : : }
1509 : 0 : }
1510 : :
1511 : : // -----------------------------------------------------------------------
1512 : :
1513 : 232702 : void ToolBox::SetItemState( sal_uInt16 nItemId, TriState eState )
1514 : : {
1515 : 232702 : sal_uInt16 nPos = GetItemPos( nItemId );
1516 : :
1517 [ + + ]: 232702 : if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1518 : : {
1519 : 232548 : ImplToolItem* pItem = &mpData->m_aItems[nPos];
1520 : :
1521 : : // Hat sich der Status geaendert
1522 [ + + ]: 232548 : if ( pItem->meState != eState )
1523 : : {
1524 : : // Wenn RadioCheck, dann vorherigen unchecken
1525 [ + + ][ - + ]: 4141 : if ( (eState == STATE_CHECK) && (pItem->mnBits & TIB_AUTOCHECK) &&
[ # # ]
1526 : : (pItem->mnBits & TIB_RADIOCHECK) )
1527 : : {
1528 : : ImplToolItem* pGroupItem;
1529 : : sal_uInt16 nGroupPos;
1530 : 0 : sal_uInt16 nItemCount = GetItemCount();
1531 : :
1532 : 0 : nGroupPos = nPos;
1533 [ # # ]: 0 : while ( nGroupPos )
1534 : : {
1535 : 0 : pGroupItem = &mpData->m_aItems[nGroupPos-1];
1536 [ # # ]: 0 : if ( pGroupItem->mnBits & TIB_RADIOCHECK )
1537 : : {
1538 [ # # ]: 0 : if ( pGroupItem->meState != STATE_NOCHECK )
1539 : 0 : SetItemState( pGroupItem->mnId, STATE_NOCHECK );
1540 : : }
1541 : : else
1542 : 0 : break;
1543 : 0 : nGroupPos--;
1544 : : }
1545 : :
1546 : 0 : nGroupPos = nPos+1;
1547 [ # # ]: 0 : while ( nGroupPos < nItemCount )
1548 : : {
1549 : 0 : pGroupItem = &mpData->m_aItems[nGroupPos];
1550 [ # # ]: 0 : if ( pGroupItem->mnBits & TIB_RADIOCHECK )
1551 : : {
1552 [ # # ]: 0 : if ( pGroupItem->meState != STATE_NOCHECK )
1553 : 0 : SetItemState( pGroupItem->mnId, STATE_NOCHECK );
1554 : : }
1555 : : else
1556 : 0 : break;
1557 : 0 : nGroupPos++;
1558 : : }
1559 : : }
1560 : :
1561 : 4141 : pItem->meState = eState;
1562 : 4141 : ImplUpdateItem( nPos );
1563 : :
1564 : : // Notify button changed event to prepare accessibility bridge
1565 : 4141 : ImplCallEventListeners( VCLEVENT_TOOLBOX_BUTTONSTATECHANGED, reinterpret_cast< void* >( nPos ) );
1566 : :
1567 : : // Notify
1568 : 4141 : ImplCallEventListeners( VCLEVENT_TOOLBOX_CLICK, reinterpret_cast< void* >( nPos ) );
1569 : : }
1570 : : }
1571 : 232702 : }
1572 : :
1573 : : // -----------------------------------------------------------------------
1574 : :
1575 : 6058 : TriState ToolBox::GetItemState( sal_uInt16 nItemId ) const
1576 : : {
1577 : 6058 : ImplToolItem* pItem = ImplGetItem( nItemId );
1578 : :
1579 [ + + ]: 6058 : if ( pItem )
1580 : 5285 : return pItem->meState;
1581 : : else
1582 : 6058 : return STATE_NOCHECK;
1583 : : }
1584 : :
1585 : : // -----------------------------------------------------------------------
1586 : :
1587 : 212199 : void ToolBox::EnableItem( sal_uInt16 nItemId, sal_Bool bEnable )
1588 : : {
1589 : 212199 : sal_uInt16 nPos = GetItemPos( nItemId );
1590 : :
1591 [ + - ]: 212199 : if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1592 : : {
1593 : 212199 : ImplToolItem* pItem = &mpData->m_aItems[nPos];
1594 [ + + ]: 212199 : if ( bEnable )
1595 : 180787 : bEnable = sal_True;
1596 [ + + ]: 212199 : if ( pItem->mbEnabled != bEnable )
1597 : : {
1598 : 15208 : pItem->mbEnabled = bEnable;
1599 : :
1600 : : // Gegebenenfalls das Fenster mit updaten
1601 [ + + ]: 15208 : if ( pItem->mpWindow )
1602 : 144 : pItem->mpWindow->Enable( pItem->mbEnabled );
1603 : :
1604 : : // Item updaten
1605 : 15208 : ImplUpdateItem( nPos );
1606 : :
1607 : 15208 : ImplUpdateInputEnable();
1608 : :
1609 : : // Notify button changed event to prepare accessibility bridge
1610 : 15208 : ImplCallEventListeners( VCLEVENT_TOOLBOX_BUTTONSTATECHANGED, reinterpret_cast< void* >( nPos ) );
1611 : :
1612 [ + + ]: 15208 : ImplCallEventListeners( bEnable ? VCLEVENT_TOOLBOX_ITEMENABLED : VCLEVENT_TOOLBOX_ITEMDISABLED, reinterpret_cast< void* >( nPos ) );
1613 : : }
1614 : : }
1615 : 212199 : }
1616 : :
1617 : : // -----------------------------------------------------------------------
1618 : :
1619 : 430 : sal_Bool ToolBox::IsItemEnabled( sal_uInt16 nItemId ) const
1620 : : {
1621 : 430 : ImplToolItem* pItem = ImplGetItem( nItemId );
1622 : :
1623 [ + - ]: 430 : if ( pItem )
1624 : 430 : return pItem->mbEnabled;
1625 : : else
1626 : 430 : return sal_False;
1627 : : }
1628 : :
1629 : : // -----------------------------------------------------------------------
1630 : :
1631 : 25957 : void ToolBox::ShowItem( sal_uInt16 nItemId, sal_Bool bVisible )
1632 : : {
1633 : 25957 : sal_uInt16 nPos = GetItemPos( nItemId );
1634 : 25957 : mpData->ImplClearLayoutData();
1635 : :
1636 [ + + ]: 25957 : if ( nPos != TOOLBOX_ITEM_NOTFOUND )
1637 : : {
1638 : 25941 : ImplToolItem* pItem = &mpData->m_aItems[nPos];
1639 [ + + ]: 25941 : if ( pItem->mbVisible != bVisible )
1640 : : {
1641 : 25044 : pItem->mbVisible = bVisible;
1642 : 25044 : ImplInvalidate( sal_False );
1643 : : }
1644 : : }
1645 : 25957 : }
1646 : :
1647 : : // -----------------------------------------------------------------------
1648 : :
1649 : 12535 : sal_Bool ToolBox::IsItemVisible( sal_uInt16 nItemId ) const
1650 : : {
1651 : 12535 : ImplToolItem* pItem = ImplGetItem( nItemId );
1652 : :
1653 [ + + ]: 12535 : if ( pItem )
1654 : 12519 : return pItem->mbVisible;
1655 : : else
1656 : 12535 : return sal_False;
1657 : : }
1658 : :
1659 : : // -----------------------------------------------------------------------
1660 : :
1661 : 430 : sal_Bool ToolBox::IsItemReallyVisible( sal_uInt16 nItemId ) const
1662 : : {
1663 : : // is the item on the visible area of the toolbox?
1664 : 430 : sal_Bool bRet = sal_False;
1665 [ + - ]: 430 : Rectangle aRect( mnLeftBorder, mnTopBorder, mnDX-mnRightBorder, mnDY-mnBottomBorder );
1666 [ + - ]: 430 : ImplToolItem* pItem = ImplGetItem( nItemId );
1667 : :
1668 [ + - ][ + + ]: 1140 : if ( pItem && pItem->mbVisible &&
[ + + ][ + - ]
[ + + ]
1669 [ + - ][ + - ]: 710 : !pItem->maRect.IsEmpty() && aRect.IsOver( pItem->maRect ) )
1670 : : {
1671 : 354 : bRet = sal_True;
1672 : : }
1673 : :
1674 : 430 : return bRet;
1675 : : }
1676 : :
1677 : : // -----------------------------------------------------------------------
1678 : :
1679 : 72480 : void ToolBox::SetItemCommand( sal_uInt16 nItemId, const XubString& rCommand )
1680 : : {
1681 : 72480 : ImplToolItem* pItem = ImplGetItem( nItemId );
1682 : :
1683 [ + - ]: 72480 : if ( pItem )
1684 : 72480 : pItem->maCommandStr = rCommand;
1685 : 72480 : }
1686 : :
1687 : : // -----------------------------------------------------------------------
1688 : :
1689 : 202223 : const XubString& ToolBox::GetItemCommand( sal_uInt16 nItemId ) const
1690 : : {
1691 : 202223 : ImplToolItem* pItem = ImplGetItem( nItemId );
1692 : :
1693 [ + - ]: 202223 : if ( pItem )
1694 : 202223 : return pItem->maCommandStr;
1695 : : else
1696 : 202223 : return ImplGetSVEmptyStr();
1697 : : }
1698 : :
1699 : : // -----------------------------------------------------------------------
1700 : :
1701 : 83297 : void ToolBox::SetQuickHelpText( sal_uInt16 nItemId, const XubString& rText )
1702 : : {
1703 : 83297 : ImplToolItem* pItem = ImplGetItem( nItemId );
1704 : :
1705 [ + - ]: 83297 : if ( pItem )
1706 : 83297 : pItem->maQuickHelpText = rText;
1707 : 83297 : }
1708 : :
1709 : : // -----------------------------------------------------------------------
1710 : :
1711 : 0 : const XubString& ToolBox::GetQuickHelpText( sal_uInt16 nItemId ) const
1712 : : {
1713 : 0 : ImplToolItem* pItem = ImplGetItem( nItemId );
1714 : :
1715 [ # # ]: 0 : if ( pItem )
1716 : 0 : return pItem->maQuickHelpText;
1717 : : else
1718 : 0 : return ImplGetSVEmptyStr();
1719 : : }
1720 : :
1721 : : // -----------------------------------------------------------------------
1722 : :
1723 : 0 : void ToolBox::SetHelpText( sal_uInt16 nItemId, const XubString& rText )
1724 : : {
1725 : 0 : ImplToolItem* pItem = ImplGetItem( nItemId );
1726 : :
1727 [ # # ]: 0 : if ( pItem )
1728 : 0 : pItem->maHelpText = rText;
1729 : 0 : }
1730 : :
1731 : : // -----------------------------------------------------------------------
1732 : :
1733 : 12 : const XubString& ToolBox::GetHelpText( sal_uInt16 nItemId ) const
1734 : : {
1735 : 12 : return ImplGetHelpText( nItemId );
1736 : : }
1737 : :
1738 : : // -----------------------------------------------------------------------
1739 : :
1740 : 2484 : void ToolBox::SetHelpId( sal_uInt16 nItemId, const rtl::OString& rHelpId )
1741 : : {
1742 : 2484 : ImplToolItem* pItem = ImplGetItem( nItemId );
1743 : :
1744 [ + - ]: 2484 : if ( pItem )
1745 : 2484 : pItem->maHelpId = rHelpId;
1746 : 2484 : }
1747 : :
1748 : : // -----------------------------------------------------------------------
1749 : :
1750 : 0 : rtl::OString ToolBox::GetHelpId( sal_uInt16 nItemId ) const
1751 : : {
1752 : 0 : rtl::OString aRet;
1753 : :
1754 [ # # ]: 0 : ImplToolItem* pItem = ImplGetItem( nItemId );
1755 : :
1756 [ # # ]: 0 : if ( pItem )
1757 : : {
1758 [ # # ]: 0 : if ( !pItem->maHelpId.isEmpty() )
1759 : 0 : aRet = pItem->maHelpId;
1760 : : else
1761 [ # # ][ # # ]: 0 : aRet = ::rtl::OUStringToOString( pItem->maCommandStr, RTL_TEXTENCODING_UTF8 );
1762 : : }
1763 : :
1764 : 0 : return aRet;
1765 : : }
1766 : :
1767 : : // -----------------------------------------------------------------------
1768 : :
1769 : 7325 : void ToolBox::SetOutStyle( sal_uInt16 nNewStyle )
1770 : : {
1771 : : // always force flat looking toolbars since NWF
1772 : 7325 : nNewStyle |= TOOLBOX_STYLE_FLAT;
1773 : :
1774 [ - + ]: 7325 : if ( mnOutStyle != nNewStyle )
1775 : : {
1776 : 0 : mnOutStyle = nNewStyle;
1777 : 0 : ImplDisableFlatButtons();
1778 : :
1779 : : // Damit das ButtonDevice neu angelegt wird
1780 [ # # ]: 0 : if ( !(mnOutStyle & TOOLBOX_STYLE_FLAT) )
1781 : : {
1782 : 0 : mnMaxItemWidth = 1;
1783 : 0 : mnMaxItemHeight = 1;
1784 : : }
1785 : :
1786 : 0 : ImplInvalidate( sal_True, sal_True );
1787 : : }
1788 : 7325 : }
1789 : :
1790 : : // -----------------------------------------------------------------------
1791 : :
1792 : : // disable key input if all items are disabled
1793 : :
1794 : 255955 : void ToolBox::ImplUpdateInputEnable()
1795 : : {
1796 [ + - ][ + - ]: 579198 : for( std::vector< ImplToolItem >::const_iterator it = mpData->m_aItems.begin();
[ + + ]
1797 : 289599 : it != mpData->m_aItems.end(); ++it )
1798 : : {
1799 [ + + ]: 283075 : if( it->mbEnabled )
1800 : : {
1801 : : // at least one useful entry
1802 : 249431 : mpData->mbKeyInputDisabled = sal_False;
1803 : 255955 : return;
1804 : : }
1805 : : }
1806 : 6524 : mpData->mbKeyInputDisabled = sal_True;
1807 : : }
1808 : :
1809 : : // -----------------------------------------------------------------------
1810 : :
1811 : 0 : void ToolBox::ImplFillLayoutData() const
1812 : : {
1813 [ # # ]: 0 : mpData->m_pLayoutData = new ToolBoxLayoutData();
1814 : :
1815 : 0 : sal_uInt16 nCount = (sal_uInt16)mpData->m_aItems.size();
1816 [ # # ]: 0 : for( sal_uInt16 i = 0; i < nCount; i++ )
1817 : : {
1818 : 0 : ImplToolItem* pItem = &mpData->m_aItems[i];
1819 : :
1820 : : // Nur malen, wenn Rechteck im PaintRectangle liegt
1821 [ # # ]: 0 : if ( !pItem->maRect.IsEmpty() )
1822 : 0 : const_cast<ToolBox*>(this)->ImplDrawItem( i, sal_False, sal_False, sal_True );
1823 : : }
1824 : 0 : }
1825 : :
1826 : : // -----------------------------------------------------------------------
1827 : :
1828 : 0 : String ToolBox::GetDisplayText() const
1829 : : {
1830 [ # # ]: 0 : if( ! mpData->m_pLayoutData )
1831 : 0 : ImplFillLayoutData();
1832 [ # # ]: 0 : return mpData->m_pLayoutData ? mpData->m_pLayoutData->m_aDisplayText : String();
1833 : : }
1834 : :
1835 : : // -----------------------------------------------------------------------
1836 : :
1837 : 0 : Rectangle ToolBox::GetCharacterBounds( sal_uInt16 nItemID, long nIndex ) const
1838 : : {
1839 : 0 : long nItemIndex = -1;
1840 [ # # ]: 0 : if( ! mpData->m_pLayoutData )
1841 : 0 : ImplFillLayoutData();
1842 [ # # ]: 0 : if( mpData->m_pLayoutData )
1843 : : {
1844 [ # # ]: 0 : for( sal_uLong i = 0; i < mpData->m_pLayoutData->m_aLineItemIds.size(); i++ )
1845 : : {
1846 [ # # ]: 0 : if( mpData->m_pLayoutData->m_aLineItemIds[i] == nItemID )
1847 : : {
1848 : 0 : nItemIndex = mpData->m_pLayoutData->m_aLineIndices[i];
1849 : 0 : break;
1850 : : }
1851 : : }
1852 : : }
1853 [ # # ][ # # ]: 0 : return (mpData->m_pLayoutData && nItemIndex != -1) ? mpData->m_pLayoutData->GetCharacterBounds( nItemIndex+nIndex ) : Rectangle();
1854 : : }
1855 : :
1856 : : // -----------------------------------------------------------------------
1857 : :
1858 : 0 : long ToolBox::GetIndexForPoint( const Point& rPoint, sal_uInt16& rItemID ) const
1859 : : {
1860 : 0 : long nIndex = -1;
1861 : 0 : rItemID = 0;
1862 [ # # ]: 0 : if( ! mpData->m_pLayoutData )
1863 : 0 : ImplFillLayoutData();
1864 [ # # ]: 0 : if( mpData->m_pLayoutData )
1865 : : {
1866 : 0 : nIndex = mpData->m_pLayoutData->GetIndexForPoint( rPoint );
1867 [ # # ]: 0 : for( sal_uLong i = 0; i < mpData->m_pLayoutData->m_aLineIndices.size(); i++ )
1868 : : {
1869 [ # # # # : 0 : if( mpData->m_pLayoutData->m_aLineIndices[i] <= nIndex &&
# # ][ # # ]
1870 : 0 : (i == mpData->m_pLayoutData->m_aLineIndices.size()-1 || mpData->m_pLayoutData->m_aLineIndices[i+1] > nIndex) )
1871 : : {
1872 : 0 : rItemID = mpData->m_pLayoutData->m_aLineItemIds[i];
1873 : 0 : break;
1874 : : }
1875 : : }
1876 : : }
1877 : 0 : return nIndex;
1878 : : }
1879 : :
1880 : : // -----------------------------------------------------------------------
1881 : :
1882 : 7382 : void ToolBox::SetDropdownClickHdl( const Link& rLink )
1883 : : {
1884 : 7382 : mpData->maDropdownClickHdl = rLink;
1885 : 7382 : }
1886 : :
1887 : 0 : const Link& ToolBox::GetDropdownClickHdl() const
1888 : : {
1889 : 0 : return mpData->maDropdownClickHdl;
1890 : : }
1891 : :
1892 : : // -----------------------------------------------------------------------
1893 : :
1894 : 9536 : void ToolBox::SetMenuType( sal_uInt16 aType )
1895 : : {
1896 [ + + ]: 9536 : if( aType != mpData->maMenuType )
1897 : : {
1898 : 5827 : mpData->maMenuType = aType;
1899 [ - + ]: 5827 : if( IsFloatingMode() )
1900 : : {
1901 : : // the menu button may have to be moved into the decoration which changes the layout
1902 : 0 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1903 [ # # ]: 0 : if( pWrapper )
1904 [ # # ]: 0 : pWrapper->ShowTitleButton( TITLE_BUTTON_MENU, ( aType & TOOLBOX_MENUTYPE_CUSTOMIZE) ? sal_True : sal_False );
1905 : :
1906 : 0 : mbFormat = sal_True;
1907 : 0 : ImplFormat();
1908 : 0 : ImplSetMinMaxFloatSize( this );
1909 : : }
1910 : : else
1911 : : {
1912 : : // trigger redraw of menu button
1913 [ - + ]: 5827 : if( !mpData->maMenubuttonItem.maRect.IsEmpty() )
1914 : 0 : Invalidate(mpData->maMenubuttonItem.maRect);
1915 : : }
1916 : : }
1917 : 9536 : }
1918 : :
1919 : 5827 : sal_uInt16 ToolBox::GetMenuType() const
1920 : : {
1921 : 5827 : return mpData->maMenuType;
1922 : : }
1923 : :
1924 : 518376 : sal_Bool ToolBox::IsMenuEnabled() const
1925 : : {
1926 : 518376 : return mpData->maMenuType != TOOLBOX_MENUTYPE_NONE;
1927 : : }
1928 : :
1929 : 10945 : PopupMenu* ToolBox::GetMenu() const
1930 : : {
1931 : 10945 : return mpData->mpMenu;
1932 : : }
1933 : :
1934 : 3709 : void ToolBox::SetMenuButtonHdl( const Link& rLink )
1935 : : {
1936 : 3709 : mpData->maMenuButtonHdl = rLink;
1937 : 3709 : }
1938 : :
1939 : : // -----------------------------------------------------------------------
1940 : :
1941 : 9129 : sal_Bool ToolBox::ImplHasClippedItems()
1942 : : {
1943 : : // are any items currently clipped ?
1944 [ + - ]: 9129 : ImplFormat();
1945 [ + - ]: 9129 : std::vector< ImplToolItem >::const_iterator it = mpData->m_aItems.begin();
1946 [ + - ][ + + ]: 333140 : while ( it != mpData->m_aItems.end() )
1947 : : {
1948 [ + - ][ + + ]: 328659 : if( it->IsClipped() )
1949 : 4648 : return sal_True;
1950 : 324011 : ++it;
1951 : : }
1952 : 9129 : return sal_False;
1953 : : }
1954 : :
1955 : 0 : void ToolBox::UpdateCustomMenu()
1956 : : {
1957 : : // fill clipped items into menu
1958 [ # # ]: 0 : if( !IsMenuEnabled() )
1959 : 0 : return;
1960 : :
1961 : 0 : PopupMenu *pMenu = GetMenu();
1962 : :
1963 : 0 : sal_uInt16 i = 0;
1964 : : // remove old entries
1965 [ # # ]: 0 : while( i < pMenu->GetItemCount() )
1966 : : {
1967 [ # # ]: 0 : if( pMenu->GetItemId( i ) >= TOOLBOX_MENUITEM_START )
1968 : : {
1969 : 0 : pMenu->RemoveItem( i );
1970 : 0 : i = 0;
1971 : : }
1972 : : else
1973 : 0 : i++;
1974 : : }
1975 : :
1976 : : // add menu items, starting from the end and inserting at pos 0
1977 [ # # ]: 0 : if ( !mpData->m_aItems.empty() )
1978 : : {
1979 [ # # # # ]: 0 : for ( std::vector< ImplToolItem >::reverse_iterator it(mpData->m_aItems.rbegin());
[ # # ]
1980 : 0 : it != mpData->m_aItems.rend(); ++it)
1981 : : {
1982 [ # # ][ # # ]: 0 : if( it->IsClipped() )
[ # # ]
1983 : : {
1984 [ # # ]: 0 : sal_uInt16 id = it->mnId + TOOLBOX_MENUITEM_START;
1985 [ # # ][ # # ]: 0 : pMenu->InsertItem( id, it->maText, it->maImage, 0, 0 );
[ # # ]
1986 [ # # ][ # # ]: 0 : pMenu->EnableItem( id, it->mbEnabled );
1987 [ # # ][ # # ]: 0 : pMenu->CheckItem( id, it->meState == STATE_CHECK );
1988 : : }
1989 : : }
1990 : : }
1991 : : }
1992 : :
1993 : 0 : IMPL_LINK( ToolBox, ImplCustomMenuListener, VclMenuEvent*, pEvent )
1994 : : {
1995 [ # # ][ # # ]: 0 : if( pEvent->GetMenu() == GetMenu() && pEvent->GetId() == VCLEVENT_MENU_SELECT )
[ # # ]
1996 : : {
1997 : 0 : sal_uInt16 id = GetMenu()->GetItemId( pEvent->GetItemPos() );
1998 [ # # ]: 0 : if( id >= TOOLBOX_MENUITEM_START )
1999 : 0 : TriggerItem( id - TOOLBOX_MENUITEM_START, sal_False, sal_False );
2000 : : }
2001 : 0 : return 0;
2002 : : }
2003 : :
2004 : 0 : IMPL_LINK_NOARG(ToolBox, ImplCallExecuteCustomMenu)
2005 : : {
2006 : 0 : mpData->mnEventId = 0;
2007 : 0 : ImplExecuteCustomMenu();
2008 : 0 : return 0;
2009 : : }
2010 : :
2011 : 0 : void ToolBox::ImplExecuteCustomMenu()
2012 : : {
2013 [ # # ]: 0 : if( IsMenuEnabled() )
2014 : : {
2015 [ # # ][ # # ]: 0 : if( GetMenuType() & TOOLBOX_MENUTYPE_CUSTOMIZE )
2016 : : // call button handler to allow for menu customization
2017 [ # # ]: 0 : mpData->maMenuButtonHdl.Call( this );
2018 : :
2019 : : // register handler
2020 [ # # ][ # # ]: 0 : GetMenu()->AddEventListener( LINK( this, ToolBox, ImplCustomMenuListener ) );
[ # # ]
2021 : :
2022 : : // make sure all disabled entries will be shown
2023 [ # # ]: 0 : GetMenu()->SetMenuFlags(
2024 [ # # ]: 0 : GetMenu()->GetMenuFlags() | MENU_FLAG_ALWAYSSHOWDISABLEDENTRIES );
2025 : :
2026 : : // toolbox might be destroyed during execute
2027 [ # # ]: 0 : ImplDelData aDelData;
2028 [ # # ]: 0 : ImplAddDel( &aDelData );
2029 [ # # ]: 0 : ImplDelData aBorderDel;
2030 : 0 : bool bBorderDel = false;
2031 : :
2032 : 0 : Window *pWin = this;
2033 : 0 : Rectangle aMenuRect = mpData->maMenubuttonItem.maRect;
2034 [ # # ][ # # ]: 0 : if( IsFloatingMode() )
2035 : : {
2036 : : // custom menu is placed in the decoration
2037 [ # # ][ # # ]: 0 : ImplBorderWindow *pBorderWin = dynamic_cast<ImplBorderWindow*>( GetWindow( WINDOW_BORDER ) );
2038 [ # # ][ # # ]: 0 : if( pBorderWin && !pBorderWin->GetMenuRect().IsEmpty() )
[ # # ][ # # ]
[ # # ]
[ # # # # ]
2039 : : {
2040 : 0 : pWin = pBorderWin;
2041 [ # # ]: 0 : aMenuRect = pBorderWin->GetMenuRect();
2042 [ # # ]: 0 : pWin->ImplAddDel( &aBorderDel );
2043 : 0 : bBorderDel = true;
2044 : : }
2045 : : }
2046 : :
2047 : 0 : sal_uInt16 uId = GetMenu()->Execute( pWin, Rectangle( ImplGetPopupPosition( aMenuRect, Size() ), Size() ),
2048 [ # # ][ # # ]: 0 : POPUPMENU_EXECUTE_DOWN | POPUPMENU_NOMOUSEUPCLOSE );
[ # # ][ # # ]
2049 : :
2050 [ # # ]: 0 : if ( aDelData.IsDead() )
2051 : : return;
2052 [ # # ]: 0 : ImplRemoveDel( &aDelData );
2053 : :
2054 [ # # ][ # # ]: 0 : if( GetMenu() )
2055 [ # # ][ # # ]: 0 : GetMenu()->RemoveEventListener( LINK( this, ToolBox, ImplCustomMenuListener ) );
[ # # ]
2056 [ # # ]: 0 : if( bBorderDel )
2057 : : {
2058 [ # # ]: 0 : if( aBorderDel.IsDead() )
2059 : : return;
2060 [ # # ]: 0 : pWin->ImplRemoveDel( &aBorderDel );
2061 : : }
2062 : :
2063 [ # # ]: 0 : pWin->Invalidate( aMenuRect );
2064 : :
2065 [ # # ]: 0 : if( uId )
2066 [ # # ][ # # ]: 0 : GrabFocusToDocument();
[ # # ][ # # ]
[ # # ]
2067 : : }
2068 : : }
2069 : :
2070 : 0 : void ToolBox::ExecuteCustomMenu()
2071 : : {
2072 [ # # ]: 0 : if( IsMenuEnabled() )
2073 : : {
2074 : : // handle custom menu asynchronously
2075 : : // to avoid problems if the toolbox is closed during menu execute
2076 : 0 : UpdateCustomMenu();
2077 [ # # ]: 0 : Application::PostUserEvent( mpData->mnEventId, LINK( this, ToolBox, ImplCallExecuteCustomMenu ) );
2078 : : }
2079 : 0 : }
2080 : :
2081 : : // -----------------------------------------------------------------------
2082 : :
2083 : : // checks override first, useful during calculation of sizes
2084 : 1122043 : sal_Bool ToolBox::ImplIsFloatingMode() const
2085 : : {
2086 : : DBG_ASSERT( !(mpData->mbAssumeDocked && mpData->mbAssumeFloating),
2087 : : "ToolBox::ImplIsFloatingMode(): cannot assume docked and floating" );
2088 : :
2089 [ - + ]: 1122043 : if( mpData->mbAssumeDocked )
2090 : 0 : return sal_False;
2091 [ - + ]: 1122043 : else if( mpData->mbAssumeFloating )
2092 : 0 : return sal_True;
2093 : : else
2094 : 1122043 : return IsFloatingMode();
2095 : : }
2096 : :
2097 : : // checks override first, useful during calculation of sizes
2098 : 139082 : sal_Bool ToolBox::ImplIsInPopupMode() const
2099 : : {
2100 [ - + ]: 139082 : if( mpData->mbAssumePopupMode )
2101 : 0 : return sal_True;
2102 : : else
2103 : : {
2104 : 139082 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
2105 [ - + ][ # # ]: 139082 : return ( pWrapper && pWrapper->GetFloatingWindow() && pWrapper->GetFloatingWindow()->IsInPopupMode() );
[ + + ]
2106 : : }
2107 : : }
2108 : :
2109 : : // -----------------------------------------------------------------------
2110 : :
2111 : 0 : void ToolBox::Lock( sal_Bool bLock )
2112 : : {
2113 : 0 : ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
2114 [ # # ]: 0 : if( !pWrapper )
2115 : 0 : return;
2116 [ # # ]: 0 : if( mpData->mbIsLocked != bLock )
2117 : : {
2118 : 0 : mpData->mbIsLocked = bLock;
2119 [ # # ]: 0 : if( !ImplIsFloatingMode() )
2120 : : {
2121 : 0 : mbCalc = sal_True;
2122 : 0 : mbFormat = sal_True;
2123 [ # # ]: 0 : SetSizePixel( CalcWindowSizePixel(1) );
2124 : 0 : Invalidate();
2125 : : }
2126 : : }
2127 : : }
2128 : :
2129 : : // -----------------------------------------------------------------------
2130 : :
2131 : 0 : sal_Bool ToolBox::AlwaysLocked()
2132 : : {
2133 : : // read config item to determine toolbox behaviour, used for subtoolbars
2134 : :
2135 : : static int nAlwaysLocked = -1;
2136 : :
2137 [ # # ]: 0 : if( nAlwaysLocked == -1 )
2138 : : {
2139 : 0 : nAlwaysLocked = 0; // ask configuration only once
2140 : :
2141 : : utl::OConfigurationNode aNode = utl::OConfigurationTreeRoot::tryCreateWithServiceFactory(
2142 : : vcl::unohelper::GetMultiServiceFactory(),
2143 [ # # ][ # # ]: 0 : OUString("/org.openoffice.Office.UI.GlobalSettings/Toolbars") ); // note: case sensitive !
[ # # ][ # # ]
2144 [ # # ]: 0 : if ( aNode.isValid() )
2145 : : {
2146 : : // feature enabled ?
2147 : 0 : sal_Bool bStatesEnabled = sal_Bool();
2148 : 0 : ::com::sun::star::uno::Any aValue = aNode.getNodeValue( OUString("StatesEnabled") );
2149 [ # # ]: 0 : if( aValue >>= bStatesEnabled )
2150 : : {
2151 [ # # ]: 0 : if( bStatesEnabled == sal_True )
2152 : : {
2153 : : // now read the locking state
2154 : : utl::OConfigurationNode aNode2 = utl::OConfigurationTreeRoot::tryCreateWithServiceFactory(
2155 : : vcl::unohelper::GetMultiServiceFactory(),
2156 [ # # ][ # # ]: 0 : OUString("/org.openoffice.Office.UI.GlobalSettings/Toolbars/States") ); // note: case sensitive !
[ # # ][ # # ]
2157 : :
2158 : 0 : sal_Bool bLocked = sal_Bool();
2159 : 0 : ::com::sun::star::uno::Any aValue2 = aNode2.getNodeValue( OUString("Locked") );
2160 [ # # ]: 0 : if( aValue2 >>= bLocked )
2161 [ # # ][ # # ]: 0 : nAlwaysLocked = (bLocked == sal_True) ? 1 : 0;
2162 : : }
2163 : 0 : }
2164 [ # # ]: 0 : }
2165 : : }
2166 : :
2167 [ # # ]: 0 : return nAlwaysLocked == 1 ? sal_True : sal_False;
2168 : : }
2169 : :
2170 : 2548 : sal_Bool ToolBox::WillUsePopupMode() const
2171 : : {
2172 : 2548 : return mpData->mbWillUsePopupMode;
2173 : : }
2174 : :
2175 : 3709 : void ToolBox::WillUsePopupMode( sal_Bool b )
2176 : : {
2177 : 3709 : mpData->mbWillUsePopupMode = b;
2178 : 3709 : }
2179 : :
2180 : 10428 : void ToolBox::ImplUpdateImageList()
2181 : : {
2182 [ - + ]: 10428 : if (mpData->mpImageListProvider != NULL)
2183 : : {
2184 : : try
2185 : : {
2186 : 0 : ImageListType eType = vcl::HIGHCONTRAST_NO;
2187 [ # # ]: 0 : if (eType != mpData->meImageListType)
2188 : : {
2189 : 0 : vcl::IImageListProvider* pImageListProvider = mpData->mpImageListProvider;
2190 [ # # ][ # # ]: 0 : SetImageList( pImageListProvider->getImageList(eType) );
[ # # # # ]
2191 : 0 : mpData->meImageListType = eType;
2192 : : }
2193 : : }
2194 : 0 : catch (com::sun::star::lang::IllegalArgumentException &) {}
2195 : : }
2196 : 10428 : }
2197 : :
2198 : 0 : void ToolBox::SetImageListProvider(vcl::IImageListProvider* _pProvider)
2199 : : {
2200 : 0 : mpData->mpImageListProvider = _pProvider;
2201 : 0 : ImplUpdateImageList();
2202 : 0 : }
2203 : : // -----------------------------------------------------------------------
2204 : :
2205 : : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
