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