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