?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tdf#130857 qt weld: Support "Java Start Parameters" dialog
[LibreOffice.git] / vcl / source / window / toolbox.cxx
blob338d817cf25de22fbbf6f339e47613d1d338a3d0
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 <vcl/toolbox.hxx>
21 #include <vcl/event.hxx>
22 #include <vcl/decoview.hxx>
23 #include <vcl/toolkit/floatwin.hxx>
24 #include <vcl/svapp.hxx>
25 #include <vcl/help.hxx>
26 #include <vcl/mnemonic.hxx>
27 #include <vcl/gradient.hxx>
28 #include <vcl/layout.hxx>
29 #include <vcl/menu.hxx>
30 #include <vcl/settings.hxx>
31 #include <vcl/ptrstyle.hxx>
32 #include <bitmaps.hlst>
33 #include <toolbarvalue.hxx>
34
35 #include <tools/poly.hxx>
36 #include <sal/log.hxx>
37 #include <o3tl/string_view.hxx>
38 #include <osl/diagnose.h>
39
40 #include <accel.hxx>
41 #include <svdata.hxx>
42 #include <window.h>
43 #include <toolbox.h>
44 #include <spin.hxx>
45 #if defined(_WIN32)
46 #include <svsys.h>
47 #endif
48
49 #include <cstdlib>
50 #include <map>
51 #include <string_view>
52 #include <vector>
53 #include <math.h>
54
55 #include "impldockingwrapper.hxx"
56
57 #define SMALLBUTTON_HSIZE 7
58 #define SMALLBUTTON_VSIZE 7
59
60 #define SMALLBUTTON_OFF_NORMAL_X 3
61 #define SMALLBUTTON_OFF_NORMAL_Y 3
62
63 #define TB_TEXTOFFSET 2
64 #define TB_IMAGETEXTOFFSET 3
65 #define TB_LINESPACING 3
66 #define TB_SPIN_SIZE 14
67 #define TB_SPIN_OFFSET 2
68 #define TB_BORDER_OFFSET1 4
69 #define TB_BORDER_OFFSET2 2
70 #define TB_MAXLINES 5
71 #define TB_MAXNOSCROLL 32765
72
73 #define TB_DRAGWIDTH 8 // the default width of the drag grip
74
75 #define TB_CALCMODE_HORZ 1
76 #define TB_CALCMODE_VERT 2
77 #define TB_CALCMODE_FLOAT 3
78
79 #define TB_WBLINESIZING (WB_SIZEABLE | WB_DOCKABLE | WB_SCROLL)
80
81 #define DOCK_LINEHSIZE (sal_uInt16(0x0001))
82 #define DOCK_LINEVSIZE (sal_uInt16(0x0002))
83 #define DOCK_LINERIGHT (sal_uInt16(0x1000))
84 #define DOCK_LINEBOTTOM (sal_uInt16(0x2000))
85 #define DOCK_LINELEFT (sal_uInt16(0x4000))
86 #define DOCK_LINETOP (sal_uInt16(0x8000))
87 #define DOCK_LINEOFFSET 3
88
89 class ImplTBDragMgr
90 {
91 private:
92 VclPtr<ToolBox> mpDragBox;
93 Point maMouseOff;
94 tools::Rectangle maRect;
95 tools::Rectangle maStartRect;
96 Accelerator maAccel;
97 sal_uInt16 mnLineMode;
98 ToolBox::ImplToolItems::size_type mnStartLines;
99
100 ImplTBDragMgr(const ImplTBDragMgr&) = delete;
101 ImplTBDragMgr& operator=(const ImplTBDragMgr&) = delete;
102
103 public:
104 ImplTBDragMgr();
105
106 void StartDragging( ToolBox* pDragBox, const Point& rPos, const tools::Rectangle& rRect, sal_uInt16 nLineMode );
107 void Dragging( const Point& rPos );
108 void EndDragging( bool bOK = true );
109 DECL_LINK( SelectHdl, Accelerator&, void );
110 };
111
112
113 static ImplTBDragMgr* ImplGetTBDragMgr()
114 {
115 ImplSVData* pSVData = ImplGetSVData();
116 if ( !pSVData->maCtrlData.mpTBDragMgr )
117 pSVData->maCtrlData.mpTBDragMgr = new ImplTBDragMgr;
118 return pSVData->maCtrlData.mpTBDragMgr;
119 }
120
121 int ToolBox::ImplGetDragWidth( const vcl::Window& rWindow, bool bHorz )
122 {
123 return ImplGetDragWidth(*rWindow.GetOutDev(), bHorz);
124 }
125 int ToolBox::ImplGetDragWidth( const vcl::RenderContext& rRenderContext, bool bHorz )
126 {
127 int nWidth = TB_DRAGWIDTH;
128 if( rRenderContext.IsNativeControlSupported( ControlType::Toolbar, ControlPart::Entire ) )
129 {
130
131 ImplControlValue aControlValue;
132 tools::Rectangle aContent, aBound;
133 tools::Rectangle aArea( Point(), rRenderContext.GetOutputSizePixel() );
134
135 if ( rRenderContext.GetNativeControlRegion(ControlType::Toolbar,
136 bHorz ? ControlPart::ThumbVert : ControlPart::ThumbHorz,
137 aArea, ControlState::NONE, aControlValue, aBound, aContent) )
138 {
139 nWidth = bHorz ? aContent.GetWidth() : aContent.GetHeight();
140 }
141 }
142
143 // increase the hit area of the drag handle according to DPI scale factor
144 nWidth *= rRenderContext.GetDPIScaleFactor();
145
146 return nWidth;
147 }
148
149 int ToolBox::ImplGetDragWidth() const
150 {
151 return ToolBox::ImplGetDragWidth( *this, mbHorz );
152 }
153
154 static ButtonType determineButtonType( ImplToolItem const * pItem, ButtonType defaultType )
155 {
156 ButtonType tmpButtonType = defaultType;
157 ToolBoxItemBits nBits = pItem->mnBits & ( ToolBoxItemBits::TEXT_ONLY | ToolBoxItemBits::ICON_ONLY );
158 if ( nBits != ToolBoxItemBits::NONE ) // item has custom setting
159 {
160 tmpButtonType = ButtonType::SYMBOLTEXT;
161 if ( nBits == ToolBoxItemBits::TEXT_ONLY )
162 tmpButtonType = ButtonType::TEXT;
163 else if ( nBits == ToolBoxItemBits::ICON_ONLY )
164 tmpButtonType = ButtonType::SYMBOLONLY;
165 }
166 return tmpButtonType;
167 }
168
169 void ToolBox::ImplUpdateDragArea() const
170 {
171 ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
172 if( pWrapper )
173 {
174 if ( ImplIsFloatingMode() || pWrapper->IsLocked() )
175 pWrapper->SetDragArea( tools::Rectangle() );
176 else
177 {
178 if( meAlign == WindowAlign::Top || meAlign == WindowAlign::Bottom )
179 pWrapper->SetDragArea( tools::Rectangle( 0, 0, ImplGetDragWidth(), GetOutputSizePixel().Height() ) );
180 else
181 pWrapper->SetDragArea( tools::Rectangle( 0, 0, GetOutputSizePixel().Width(), ImplGetDragWidth() ) );
182 }
183 }
184 }
185
186 void ToolBox::ImplCalcBorder( WindowAlign eAlign, tools::Long& rLeft, tools::Long& rTop,
187 tools::Long& rRight, tools::Long& rBottom ) const
188 {
189 if( ImplIsFloatingMode() || !(mnWinStyle & WB_BORDER) )
190 {
191 // no border in floating mode
192 rLeft = rTop = rRight = rBottom = 0;
193 return;
194 }
195
196 ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
197
198 // reserve DragArea only for dockable toolbars
199 int dragwidth = ( pWrapper && !pWrapper->IsLocked() ) ? ImplGetDragWidth() : 0;
200
201 // no shadow border for dockable toolbars and toolbars with WB_NOSHADOW bit set, e.g. Calc's formulabar
202 int borderwidth = ( pWrapper || mnWinStyle & WB_NOSHADOW ) ? 0 : 2;
203
204 if ( eAlign == WindowAlign::Top )
205 {
206 rLeft = borderwidth+dragwidth;
207 rTop = borderwidth;
208 rRight = borderwidth;
209 rBottom = 0;
210 }
211 else if ( eAlign == WindowAlign::Left )
212 {
213 rLeft = borderwidth;
214 rTop = borderwidth+dragwidth;
215 rRight = 0;
216 rBottom = borderwidth;
217 }
218 else if ( eAlign == WindowAlign::Bottom )
219 {
220 rLeft = borderwidth+dragwidth;
221 rTop = 0;
222 rRight = borderwidth;
223 rBottom = borderwidth;
224 }
225 else
226 {
227 rLeft = 0;
228 rTop = borderwidth+dragwidth;
229 rRight = borderwidth;
230 rBottom = borderwidth;
231 }
232 }
233
234 void ToolBox::ImplCheckUpdate()
235 {
236 // remove any pending invalidates to avoid
237 // have them triggered when paint is locked (see mpData->mbIsPaintLocked)
238 // which would result in erasing the background only and not painting any items
239 // this must not be done when we're already in Paint()
240
241 // this is only required for transparent toolbars (see ImplDrawTransparentBackground() )
242 if( !IsBackground() && HasPaintEvent() && !IsInPaint() )
243 PaintImmediately();
244 }
245
246 void ToolBox::ImplDrawGrip(vcl::RenderContext& rRenderContext,
247 const tools::Rectangle &aDragArea, int nDragWidth, WindowAlign eAlign, bool bHorz)
248 {
249 bool bNativeOk = false;
250 const ControlPart ePart = bHorz ? ControlPart::ThumbVert : ControlPart::ThumbHorz;
251 const Size aSz( rRenderContext.GetOutputSizePixel() );
252 if (rRenderContext.IsNativeControlSupported(ControlType::Toolbar, ePart))
253 {
254 ToolbarValue aToolbarValue;
255 aToolbarValue.maGripRect = aDragArea;
256
257 tools::Rectangle aCtrlRegion(Point(), aSz);
258
259 bNativeOk = rRenderContext.DrawNativeControl( ControlType::Toolbar, ePart,
260 aCtrlRegion, ControlState::ENABLED, aToolbarValue, OUString() );
261 }
262
263 if( bNativeOk )
264 return;
265
266 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
267 rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
268 rRenderContext.SetFillColor(rStyleSettings.GetShadowColor());
269
270 float fScaleFactor = rRenderContext.GetDPIScaleFactor();
271
272 if (eAlign == WindowAlign::Top || eAlign == WindowAlign::Bottom)
273 {
274 int height = static_cast<int>(0.6 * aSz.Height() + 0.5);
275 int i = (aSz.Height() - height) / 2;
276 height += i;
277 while (i <= height)
278 {
279 int x = nDragWidth / 2;
280 rRenderContext.DrawEllipse(tools::Rectangle(Point(x, i), Size(2 * fScaleFactor, 2 * fScaleFactor)));
281 i += 4 * fScaleFactor;
282 }
283 }
284 else
285 {
286 int width = static_cast<int>(0.6 * aSz.Width() + 0.5);
287 int i = (aSz.Width() - width) / 2;
288 width += i;
289 while (i <= width)
290 {
291 int y = nDragWidth / 2;
292 rRenderContext.DrawEllipse(tools::Rectangle(Point(i, y), Size(2 * fScaleFactor, 2 * fScaleFactor)));
293 i += 4 * fScaleFactor;
294 }
295 }
296 }
297
298 void ToolBox::ImplDrawGrip(vcl::RenderContext& rRenderContext)
299 {
300 ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper(this);
301 if( pWrapper && !pWrapper->GetDragArea().IsEmpty() )
302 {
303 // execute pending paint requests
304 ImplCheckUpdate();
305 ImplDrawGrip( rRenderContext, pWrapper->GetDragArea(),
306 ImplGetDragWidth(), meAlign, mbHorz );
307 }
308 }
309
310 void ToolBox::ImplDrawGradientBackground(vcl::RenderContext& rRenderContext)
311 {
312 // draw a nice gradient
313
314 Color startCol, endCol;
315 const StyleSettings rSettings = rRenderContext.GetSettings().GetStyleSettings();
316
317 startCol = rSettings.GetFaceGradientColor();
318 endCol = rSettings.GetFaceColor();
319 if (rSettings.GetHighContrastMode())
320 // no 'extreme' gradient when high contrast
321 startCol = endCol;
322
323 Gradient g;
324 g.SetAngle(Degree10(mbHorz ? 0 : 900));
325 g.SetStyle(css::awt::GradientStyle_LINEAR);
326
327 g.SetStartColor(startCol);
328 g.SetEndColor(endCol);
329
330 bool bLineColor = rRenderContext.IsLineColor();
331 Color aOldCol = rRenderContext.GetLineColor();
332 rRenderContext.SetLineColor(rRenderContext.GetSettings().GetStyleSettings().GetShadowColor());
333
334 Size aFullSz(GetOutputSizePixel());
335 Size aLineSz(aFullSz);
336
337 // use the linesize only when floating
338 // full window height is used when docked (single line)
339 if (ImplIsFloatingMode())
340 {
341 tools::Long nLineSize;
342 if (mbHorz)
343 {
344 nLineSize = mnMaxItemHeight;
345 if (mnWinHeight > mnMaxItemHeight)
346 nLineSize = mnWinHeight;
347
348 aLineSz.setHeight( nLineSize );
349 }
350 else
351 {
352 nLineSize = mnMaxItemWidth;
353 aLineSz.setWidth( nLineSize );
354 }
355 }
356
357 tools::Long nLeft, nTop, nRight, nBottom;
358 ImplCalcBorder(meAlign, nLeft, nTop, nRight, nBottom);
359
360 Size aTopLineSz(aLineSz);
361 Size aBottomLineSz(aLineSz);
362
363 if (mnWinStyle & WB_BORDER)
364 {
365 if (mbHorz)
366 {
367 aTopLineSz.AdjustHeight(TB_BORDER_OFFSET2 + nTop );
368 aBottomLineSz.AdjustHeight(TB_BORDER_OFFSET2 + nBottom );
369
370 if (mnCurLines == 1)
371 aTopLineSz.AdjustHeight(TB_BORDER_OFFSET2 + nBottom );
372 }
373 else
374 {
375 aTopLineSz.AdjustWidth(TB_BORDER_OFFSET1 + nLeft );
376 aBottomLineSz.AdjustWidth(TB_BORDER_OFFSET1 + nRight );
377
378 if (mnCurLines == 1)
379 aTopLineSz.AdjustWidth(TB_BORDER_OFFSET1 + nLeft );
380 }
381 }
382
383 if (mbLineSpacing)
384 {
385 if (mbHorz)
386 {
387 aLineSz.AdjustHeight(TB_LINESPACING );
388 if (mnCurLines > 1)
389 aTopLineSz.AdjustHeight(TB_LINESPACING );
390 }
391 else
392 {
393 aLineSz.AdjustWidth(TB_LINESPACING );
394 if (mnCurLines > 1)
395 aTopLineSz.AdjustWidth(TB_LINESPACING );
396 }
397 }
398
399 if (mbHorz)
400 {
401 tools::Long y = 0;
402
403 rRenderContext.DrawGradient(tools::Rectangle(0, y, aTopLineSz.Width(), y + aTopLineSz.Height()), g);
404 y += aTopLineSz.Height();
405
406 while (y < (mnDY - aBottomLineSz.Height()))
407 {
408 rRenderContext.DrawGradient(tools::Rectangle(0, y, aLineSz.Width(), y + aLineSz.Height()), g);
409 y += aLineSz.Height();
410 }
411
412 rRenderContext.DrawGradient(tools::Rectangle(0, y, aBottomLineSz.Width(), y + aBottomLineSz.Height()), g);
413 }
414 else
415 {
416 tools::Long x = 0;
417
418 rRenderContext.DrawGradient(tools::Rectangle(x, 0, x + aTopLineSz.Width(), aTopLineSz.Height()), g);
419 x += aTopLineSz.Width();
420
421 while (x < (mnDX - aBottomLineSz.Width()))
422 {
423 rRenderContext.DrawGradient(tools::Rectangle(x, 0, x + aLineSz.Width(), aLineSz.Height()), g);
424 x += aLineSz.Width();
425 }
426
427 rRenderContext.DrawGradient(tools::Rectangle( x, 0, x + aBottomLineSz.Width(), aBottomLineSz.Height()), g);
428 }
429
430 if( bLineColor )
431 rRenderContext.SetLineColor( aOldCol );
432
433 }
434
435 bool ToolBox::ImplDrawNativeBackground(vcl::RenderContext& rRenderContext) const
436 {
437 // use NWF
438 tools::Rectangle aCtrlRegion(Point(), GetOutputSizePixel());
439
440 return rRenderContext.DrawNativeControl( ControlType::Toolbar, mbHorz ? ControlPart::DrawBackgroundHorz : ControlPart::DrawBackgroundVert,
441 aCtrlRegion, ControlState::ENABLED, ImplControlValue(), OUString() );
442 }
443
444 void ToolBox::ImplDrawTransparentBackground(const vcl::Region &rRegion)
445 {
446 // just invalidate to trigger paint of the parent
447 const bool bOldPaintLock = mpData->mbIsPaintLocked;
448 mpData->mbIsPaintLocked = true;
449
450 // send an invalidate to the first opaque parent and invalidate the whole hierarchy from there (noclipchildren)
451 Invalidate(rRegion, InvalidateFlags::Update | InvalidateFlags::NoClipChildren);
452
453 mpData->mbIsPaintLocked = bOldPaintLock;
454 }
455
456 void ToolBox::ImplDrawConstantBackground(vcl::RenderContext& rRenderContext, const vcl::Region &rRegion, bool bIsInPopupMode)
457 {
458 // draw a constant color
459 if (!bIsInPopupMode)
460 {
461 // default background
462 rRenderContext.Erase(rRegion.GetBoundRect());
463 }
464 else
465 {
466 // use different color in popupmode
467 const StyleSettings rSettings = rRenderContext.GetSettings().GetStyleSettings();
468 Wallpaper aWallpaper(rSettings.GetFaceGradientColor());
469 rRenderContext.DrawWallpaper(rRegion.GetBoundRect(), aWallpaper);
470 }
471 }
472
473 void ToolBox::ImplDrawBackground(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
474 {
475 // execute pending paint requests
476 ImplCheckUpdate();
477
478 ImplDockingWindowWrapper* pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper(this);
479 bool bIsInPopupMode = ImplIsInPopupMode();
480
481 vcl::Region aPaintRegion(rRect);
482
483 // make sure we do not invalidate/erase too much
484 if (IsInPaint())
485 aPaintRegion.Intersect(GetOutDev()->GetActiveClipRegion());
486
487 rRenderContext.Push(vcl::PushFlags::CLIPREGION);
488 rRenderContext.IntersectClipRegion( aPaintRegion );
489
490 if (!pWrapper)
491 {
492 // no gradient for ordinary toolbars (not dockable)
493 if( !IsBackground() && !IsInPaint() )
494 ImplDrawTransparentBackground(aPaintRegion);
495 else
496 ImplDrawConstantBackground(rRenderContext, aPaintRegion, bIsInPopupMode);
497 }
498 else
499 {
500 // toolbars known to the dockingmanager will be drawn using NWF or a gradient
501 // docked toolbars are transparent and NWF is already used in the docking area which is their common background
502 // so NWF is used here for floating toolbars only
503 bool bNativeOk = false;
504 if( ImplIsFloatingMode() && rRenderContext.IsNativeControlSupported( ControlType::Toolbar, ControlPart::Entire) )
505 bNativeOk = ImplDrawNativeBackground(rRenderContext);
506 if (!bNativeOk)
507 {
508 const StyleSettings rSetting = Application::GetSettings().GetStyleSettings();
509 if (!IsBackground())
510 {
511 if (!IsInPaint())
512 ImplDrawTransparentBackground(aPaintRegion);
513 }
514 else
515 ImplDrawGradientBackground(rRenderContext);
516 }
517 }
518
519 // restore clip region
520 rRenderContext.Pop();
521 }
522
523 void ToolBox::ImplErase(vcl::RenderContext& rRenderContext, const tools::Rectangle &rRect, bool bHighlight, bool bHasOpenPopup)
524 {
525 // the background of non NWF buttons is painted in a constant color
526 // to have the same highlight color (transparency in DrawSelectionBackground())
527 // items with open popups will also painted using a constant color
528 if (!mpData->mbNativeButtons &&
529 (bHighlight || !(GetStyle() & WB_3DLOOK)))
530 {
531 if (GetStyle() & WB_3DLOOK)
532 {
533 rRenderContext.Push(vcl::PushFlags::LINECOLOR | vcl::PushFlags::FILLCOLOR);
534 rRenderContext.SetLineColor();
535 if (bHasOpenPopup)
536 // choose the same color as the popup will use
537 rRenderContext.SetFillColor(rRenderContext.GetSettings().GetStyleSettings().GetFaceColor());
538 else
539 rRenderContext.SetFillColor(rRenderContext.GetSettings().GetStyleSettings().GetWindowColor());
540
541 rRenderContext.DrawRect(rRect);
542 rRenderContext.Pop();
543 }
544 else
545 ImplDrawBackground(rRenderContext, rRect);
546 }
547 else
548 ImplDrawBackground(rRenderContext, rRect);
549 }
550
551 void ToolBox::ImplDrawBorder(vcl::RenderContext& rRenderContext)
552 {
553 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
554 tools::Long nDX = mnDX;
555 tools::Long nDY = mnDY;
556
557 ImplDockingWindowWrapper* pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper(this);
558
559 // draw borders for ordinary toolbars only (not dockable), do not draw borders for toolbars with WB_NOSHADOW bit set,
560 // e.g. Calc's formulabar
561
562 if( pWrapper || mnWinStyle & WB_NOSHADOW )
563 return;
564
565 if (meAlign == WindowAlign::Bottom)
566 {
567 // draw bottom border
568 rRenderContext.SetLineColor( rStyleSettings.GetShadowColor() );
569 rRenderContext.DrawLine( Point( 0, nDY-2 ), Point( nDX-1, nDY-2 ) );
570 rRenderContext.SetLineColor( rStyleSettings.GetLightColor() );
571 rRenderContext.DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) );
572 }
573 else
574 {
575 // draw top border
576 rRenderContext.SetLineColor( rStyleSettings.GetShadowColor() );
577 rRenderContext.DrawLine( Point( 0, 0 ), Point( nDX-1, 0 ) );
578 rRenderContext.SetLineColor( rStyleSettings.GetLightColor() );
579 rRenderContext.DrawLine( Point( 0, 1 ), Point( nDX-1, 1 ) );
580
581 if (meAlign == WindowAlign::Left || meAlign == WindowAlign::Right)
582 {
583 if (meAlign == WindowAlign::Left)
584 {
585 // draw left-bottom border
586 rRenderContext.SetLineColor( rStyleSettings.GetShadowColor() );
587 rRenderContext.DrawLine( Point( 0, 0 ), Point( 0, nDY-1 ) );
588 rRenderContext.DrawLine( Point( 0, nDY-2 ), Point( nDX-1, nDY-2 ) );
589 rRenderContext.SetLineColor( rStyleSettings.GetLightColor() );
590 rRenderContext.DrawLine( Point( 1, 1 ), Point( 1, nDY-3 ) );
591 rRenderContext.DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) );
592 }
593 else
594 {
595 // draw right-bottom border
596 rRenderContext.SetLineColor( rStyleSettings.GetShadowColor() );
597 rRenderContext.DrawLine( Point( nDX-2, 0 ), Point( nDX-2, nDY-3 ) );
598 rRenderContext.DrawLine( Point( 0, nDY-2 ), Point( nDX-2, nDY-2 ) );
599 rRenderContext.SetLineColor( rStyleSettings.GetLightColor() );
600 rRenderContext.DrawLine( Point( nDX-1, 0 ), Point( nDX-1, nDY-1 ) );
601 rRenderContext.DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) );
602 }
603 }
604 }
605
606 if ( meAlign == WindowAlign::Bottom || meAlign == WindowAlign::Top )
607 {
608 // draw right border
609 rRenderContext.SetLineColor( rStyleSettings.GetShadowColor() );
610 rRenderContext.DrawLine( Point( nDX-2, 0 ), Point( nDX-2, nDY-1 ) );
611 rRenderContext.SetLineColor( rStyleSettings.GetLightColor() );
612 rRenderContext.DrawLine( Point( nDX-1, 0 ), Point( nDX-1, nDY-1 ) );
613 }
614 }
615
616 static bool ImplIsFixedControl( const ImplToolItem *pItem )
617 {
618 return ( pItem->mpWindow &&
619 (pItem->mbNonInteractiveWindow ||
620 pItem->mpWindow->GetType() == WindowType::FIXEDTEXT ||
621 pItem->mpWindow->GetType() == WindowType::FIXEDLINE ||
622 pItem->mpWindow->GetType() == WindowType::GROUPBOX) );
623 }
624
625 const ImplToolItem *ToolBox::ImplGetFirstClippedItem() const
626 {
627 for (auto & item : mpData->m_aItems)
628 {
629 if( item.IsClipped() )
630 return &item;
631 }
632 return nullptr;
633 }
634
635 Size ToolBox::ImplCalcSize( ImplToolItems::size_type nCalcLines, sal_uInt16 nCalcMode )
636 {
637 sal_Int32 nMax;
638 tools::Long nLeft = 0;
639 tools::Long nTop = 0;
640 tools::Long nRight = 0;
641 tools::Long nBottom = 0;
642 Size aSize;
643 WindowAlign eOldAlign = meAlign;
644 bool bOldHorz = mbHorz;
645 bool bOldAssumeDocked = mpData->mbAssumeDocked;
646 bool bOldAssumeFloating = mpData->mbAssumeFloating;
647
648 if ( nCalcMode )
649 {
650 bool bOldFloatingMode = ImplIsFloatingMode();
651
652 mpData->mbAssumeDocked = false;
653 mpData->mbAssumeFloating = false;
654
655 if ( nCalcMode == TB_CALCMODE_HORZ )
656 {
657 mpData->mbAssumeDocked = true; // force non-floating mode during calculation
658 ImplCalcBorder( WindowAlign::Top, nLeft, nTop, nRight, nBottom );
659 mbHorz = true;
660 if ( mbHorz != bOldHorz )
661 meAlign = WindowAlign::Top;
662 }
663 else if ( nCalcMode == TB_CALCMODE_VERT )
664 {
665 mpData->mbAssumeDocked = true; // force non-floating mode during calculation
666 ImplCalcBorder( WindowAlign::Left, nLeft, nTop, nRight, nBottom );
667 mbHorz = false;
668 if ( mbHorz != bOldHorz )
669 meAlign = WindowAlign::Left;
670 }
671 else if ( nCalcMode == TB_CALCMODE_FLOAT )
672 {
673 mpData->mbAssumeFloating = true; // force non-floating mode during calculation
674 nLeft = nTop = nRight = nBottom = 0;
675 mbHorz = true;
676 if ( mbHorz != bOldHorz )
677 meAlign = WindowAlign::Top;
678 }
679
680 if ( (meAlign != eOldAlign) || (mbHorz != bOldHorz) ||
681 (ImplIsFloatingMode() != bOldFloatingMode ) )
682 mbCalc = true;
683 }
684 else
685 ImplCalcBorder( meAlign, nLeft, nTop, nRight, nBottom );
686
687 ImplCalcItem();
688
689 if( !nCalcMode && ImplIsFloatingMode() )
690 {
691 aSize = ImplCalcFloatSize( nCalcLines );
692 }
693 else
694 {
695 if ( mbHorz )
696 {
697 if ( mnWinHeight > mnMaxItemHeight )
698 aSize.setHeight( nCalcLines * mnWinHeight );
699 else
700 aSize.setHeight( nCalcLines * mnMaxItemHeight );
701
702 if ( mbLineSpacing )
703 aSize.AdjustHeight((nCalcLines-1)*TB_LINESPACING );
704
705 if ( mnWinStyle & WB_BORDER )
706 aSize.AdjustHeight((TB_BORDER_OFFSET2*2) + nTop + nBottom );
707
708 nMax = 0;
709 ImplCalcBreaks( TB_MAXNOSCROLL, &nMax, mbHorz );
710 if ( nMax )
711 aSize.AdjustWidth(nMax );
712
713 if ( mnWinStyle & WB_BORDER )
714 aSize.AdjustWidth((TB_BORDER_OFFSET1*2) + nLeft + nRight );
715 }
716 else
717 {
718 aSize.setWidth( nCalcLines * mnMaxItemWidth );
719
720 if ( mbLineSpacing )
721 aSize.AdjustWidth((nCalcLines-1)*TB_LINESPACING );
722
723 if ( mnWinStyle & WB_BORDER )
724 aSize.AdjustWidth((TB_BORDER_OFFSET2*2) + nLeft + nRight );
725
726 nMax = 0;
727 ImplCalcBreaks( TB_MAXNOSCROLL, &nMax, mbHorz );
728 if ( nMax )
729 aSize.AdjustHeight(nMax );
730
731 if ( mnWinStyle & WB_BORDER )
732 aSize.AdjustHeight((TB_BORDER_OFFSET1*2) + nTop + nBottom );
733 }
734 }
735 // restore previous values
736 if ( nCalcMode )
737 {
738 mpData->mbAssumeDocked = bOldAssumeDocked;
739 mpData->mbAssumeFloating = bOldAssumeFloating;
740 if ( (meAlign != eOldAlign) || (mbHorz != bOldHorz) )
741 {
742 meAlign = eOldAlign;
743 mbHorz = bOldHorz;
744 mbCalc = true;
745 }
746 }
747
748 return aSize;
749 }
750
751 void ToolBox::ImplCalcFloatSizes()
752 {
753 if ( !maFloatSizes.empty() )
754 return;
755
756 // calculate the minimal size, i.e. where the biggest item just fits
757 tools::Long nCalcSize = 0;
758
759 for (auto const& item : mpData->m_aItems)
760 {
761 if ( item.mbVisible )
762 {
763 if ( item.mpWindow )
764 {
765 tools::Long nTempSize = item.mpWindow->GetSizePixel().Width();
766 if ( nTempSize > nCalcSize )
767 nCalcSize = nTempSize;
768 }
769 else
770 {
771 if( item.maItemSize.Width() > nCalcSize )
772 nCalcSize = item.maItemSize.Width();
773 }
774 }
775 }
776
777 // calc an upper bound for ImplCalcBreaks below
778 tools::Long upperBoundWidth = nCalcSize * mpData->m_aItems.size();
779
780 ImplToolItems::size_type nLines;
781 ImplToolItems::size_type nCalcLines;
782 ImplToolItems::size_type nTempLines;
783 sal_Int32 nMaxLineWidth;
784 nCalcLines = ImplCalcBreaks( nCalcSize, &nMaxLineWidth, true );
785
786 maFloatSizes.reserve( nCalcLines );
787
788 nTempLines = nLines = nCalcLines;
789 while ( nLines )
790 {
791 tools::Long nHeight = ImplCalcSize( nTempLines, TB_CALCMODE_FLOAT ).Height();
792
793 ImplToolSize aSize;
794 aSize.mnWidth = nMaxLineWidth+(TB_BORDER_OFFSET1*2);
795 aSize.mnHeight = nHeight;
796 aSize.mnLines = nTempLines;
797 maFloatSizes.push_back( aSize );
798 nLines--;
799 if ( nLines )
800 {
801 do
802 {
803 nCalcSize += mnMaxItemWidth;
804 nTempLines = ImplCalcBreaks( nCalcSize, &nMaxLineWidth, true );
805 }
806 while ((nCalcSize < upperBoundWidth) && (nLines < nTempLines)); // implies nTempLines>1
807 if ( nTempLines < nLines )
808 nLines = nTempLines;
809 }
810 }
811 }
812
813 Size ToolBox::ImplCalcFloatSize( ImplToolItems::size_type& rLines )
814 {
815 ImplCalcFloatSizes();
816
817 if ( !rLines )
818 {
819 rLines = mnFloatLines;
820 if ( !rLines )
821 rLines = mnLines;
822 }
823
824 sal_uInt16 i = 0;
825 while ( i + 1u < maFloatSizes.size() && rLines < maFloatSizes[i].mnLines )
826 {
827 i++;
828 }
829
830 Size aSize( maFloatSizes[i].mnWidth, maFloatSizes[i].mnHeight );
831 rLines = maFloatSizes[i].mnLines;
832
833 return aSize;
834 }
835
836 void ToolBox::ImplCalcMinMaxFloatSize( Size& rMinSize, Size& rMaxSize )
837 {
838 ImplCalcFloatSizes();
839
840 sal_uInt16 i = 0;
841 rMinSize = Size( maFloatSizes[i].mnWidth, maFloatSizes[i].mnHeight );
842 rMaxSize = Size( maFloatSizes[i].mnWidth, maFloatSizes[i].mnHeight );
843 while ( ++i < maFloatSizes.size() )
844 {
845 if( maFloatSizes[i].mnWidth < rMinSize.Width() )
846 rMinSize.setWidth( maFloatSizes[i].mnWidth );
847 if( maFloatSizes[i].mnHeight < rMinSize.Height() )
848 rMinSize.setHeight( maFloatSizes[i].mnHeight );
849
850 if( maFloatSizes[i].mnWidth > rMaxSize.Width() )
851 rMaxSize.setWidth( maFloatSizes[i].mnWidth );
852 if( maFloatSizes[i].mnHeight > rMaxSize.Height() )
853 rMaxSize.setHeight( maFloatSizes[i].mnHeight );
854 }
855 }
856
857 void ToolBox::ImplSetMinMaxFloatSize()
858 {
859 ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
860 Size aMinSize, aMaxSize;
861 ImplCalcMinMaxFloatSize( aMinSize, aMaxSize );
862 if( pWrapper )
863 {
864 pWrapper->SetMinOutputSizePixel( aMinSize );
865 pWrapper->SetMaxOutputSizePixel( aMaxSize );
866 pWrapper->ShowMenuTitleButton( bool( GetMenuType() & ToolBoxMenuType::Customize) );
867 }
868 else
869 {
870 // TODO: change SetMinOutputSizePixel to be not inline
871 SetMinOutputSizePixel( aMinSize );
872 SetMaxOutputSizePixel( aMaxSize );
873 }
874 }
875
876 ToolBox::ImplToolItems::size_type ToolBox::ImplCalcLines( tools::Long nToolSize ) const
877 {
878 tools::Long nLineHeight;
879
880 if ( mbHorz )
881 {
882 if ( mnWinHeight > mnMaxItemHeight )
883 nLineHeight = mnWinHeight;
884 else
885 nLineHeight = mnMaxItemHeight;
886 }
887 else
888 nLineHeight = mnMaxItemWidth;
889
890 if ( mnWinStyle & WB_BORDER )
891 nToolSize -= TB_BORDER_OFFSET2*2;
892
893 if ( mbLineSpacing )
894 {
895 nLineHeight += TB_LINESPACING;
896 nToolSize += TB_LINESPACING;
897 }
898
899 // #i91917# always report at least one line
900 tools::Long nLines = nToolSize/nLineHeight;
901 if( nLines < 1 )
902 nLines = 1;
903
904 return nLines;
905 }
906
907 sal_uInt16 ToolBox::ImplTestLineSize( const Point& rPos ) const
908 {
909 if ( !ImplIsFloatingMode() &&
910 (!mbScroll || (mnLines > 1) || (mnCurLines > mnVisLines)) )
911 {
912 WindowAlign eAlign = GetAlign();
913
914 if ( eAlign == WindowAlign::Left )
915 {
916 if ( rPos.X() > mnDX-DOCK_LINEOFFSET )
917 return DOCK_LINEHSIZE | DOCK_LINERIGHT;
918 }
919 else if ( eAlign == WindowAlign::Top )
920 {
921 if ( rPos.Y() > mnDY-DOCK_LINEOFFSET )
922 return DOCK_LINEVSIZE | DOCK_LINEBOTTOM;
923 }
924 else if ( eAlign == WindowAlign::Right )
925 {
926 if ( rPos.X() < DOCK_LINEOFFSET )
927 return DOCK_LINEHSIZE | DOCK_LINELEFT;
928 }
929 else if ( eAlign == WindowAlign::Bottom )
930 {
931 if ( rPos.Y() < DOCK_LINEOFFSET )
932 return DOCK_LINEVSIZE | DOCK_LINETOP;
933 }
934 }
935
936 return 0;
937 }
938
939 void ToolBox::ImplLineSizing( const Point& rPos, tools::Rectangle& rRect, sal_uInt16 nLineMode )
940 {
941 bool bHorz;
942 tools::Long nOneLineSize;
943 tools::Long nCurSize;
944 tools::Long nMaxSize;
945 tools::Long nSize;
946 Size aSize;
947
948 if ( nLineMode & DOCK_LINERIGHT )
949 {
950 nCurSize = rPos.X() - rRect.Left();
951 bHorz = false;
952 }
953 else if ( nLineMode & DOCK_LINEBOTTOM )
954 {
955 nCurSize = rPos.Y() - rRect.Top();
956 bHorz = true;
957 }
958 else if ( nLineMode & DOCK_LINELEFT )
959 {
960 nCurSize = rRect.Right() - rPos.X();
961 bHorz = false;
962 }
963 else if ( nLineMode & DOCK_LINETOP )
964 {
965 nCurSize = rRect.Bottom() - rPos.Y();
966 bHorz = true;
967 }
968 else {
969 OSL_FAIL( "ImplLineSizing: Trailing else" );
970 nCurSize = 0;
971 bHorz = false;
972 }
973
974 Size aWinSize = GetSizePixel();
975 ImplToolItems::size_type nMaxLines = std::max(mnLines, mnCurLines);
976 if ( nMaxLines > TB_MAXLINES )
977 nMaxLines = TB_MAXLINES;
978 if ( bHorz )
979 {
980 nOneLineSize = ImplCalcSize( 1 ).Height();
981 nMaxSize = - 20;
982 if ( nMaxSize < aWinSize.Height() )
983 nMaxSize = aWinSize.Height();
984 }
985 else
986 {
987 nOneLineSize = ImplCalcSize( 1 ).Width();
988 nMaxSize = - 20;
989 if ( nMaxSize < aWinSize.Width() )
990 nMaxSize = aWinSize.Width();
991 }
992
993 ImplToolItems::size_type i = 1;
994 if ( nCurSize <= nOneLineSize )
995 nSize = nOneLineSize;
996 else
997 {
998 nSize = 0;
999 while ( (nSize < nCurSize) && (i < nMaxLines) )
1000 {
1001 i++;
1002 aSize = ImplCalcSize( i );
1003 if ( bHorz )
1004 nSize = aSize.Height();
1005 else
1006 nSize = aSize.Width();
1007 if ( nSize > nMaxSize )
1008 {
1009 i--;
1010 aSize = ImplCalcSize( i );
1011 if ( bHorz )
1012 nSize = aSize.Height();
1013 else
1014 nSize = aSize.Width();
1015 break;
1016 }
1017 }
1018 }
1019
1020 if ( nLineMode & DOCK_LINERIGHT )
1021 rRect.SetRight( rRect.Left()+nSize-1 );
1022 else if ( nLineMode & DOCK_LINEBOTTOM )
1023 rRect.SetBottom( rRect.Top()+nSize-1 );
1024 else if ( nLineMode & DOCK_LINELEFT )
1025 rRect.SetLeft( rRect.Right()-nSize );
1026 else
1027 rRect.SetTop( rRect.Bottom()-nSize );
1028
1029 mnDockLines = i;
1030 }
1031
1032 ImplTBDragMgr::ImplTBDragMgr()
1033 : mpDragBox(nullptr)
1034 , mnLineMode(0)
1035 , mnStartLines(0)
1036 {
1037 maAccel.InsertItem( KEY_RETURN, vcl::KeyCode( KEY_RETURN ) );
1038 maAccel.InsertItem( KEY_ESCAPE, vcl::KeyCode( KEY_ESCAPE ) );
1039 maAccel.SetSelectHdl( LINK( this, ImplTBDragMgr, SelectHdl ) );
1040 }
1041
1042 void ImplTBDragMgr::StartDragging( ToolBox* pToolBox,
1043 const Point& rPos, const tools::Rectangle& rRect,
1044 sal_uInt16 nDragLineMode )
1045 {
1046 mpDragBox = pToolBox;
1047 pToolBox->CaptureMouse();
1048 pToolBox->mbDragging = true;
1049 Application::InsertAccel( &maAccel );
1050
1051 mnLineMode = nDragLineMode;
1052 mnStartLines = pToolBox->mnDockLines;
1053
1054 // calculate MouseOffset
1055 maMouseOff.setX( rRect.Left() - rPos.X() );
1056 maMouseOff.setY( rRect.Top() - rPos.Y() );
1057 maRect = rRect;
1058 maStartRect = rRect;
1059 pToolBox->ShowTracking( maRect );
1060 }
1061
1062 void ImplTBDragMgr::Dragging( const Point& rPos )
1063 {
1064 mpDragBox->ImplLineSizing( rPos, maRect, mnLineMode );
1065 Point aOff = mpDragBox->OutputToScreenPixel( Point() );
1066 maRect.Move( aOff.X(), aOff.Y() );
1067 mpDragBox->Docking( rPos, maRect );
1068 maRect.Move( -aOff.X(), -aOff.Y() );
1069 mpDragBox->ShowTracking( maRect );
1070 }
1071
1072 void ImplTBDragMgr::EndDragging( bool bOK )
1073 {
1074 mpDragBox->HideTracking();
1075 if (mpDragBox->IsMouseCaptured())
1076 mpDragBox->ReleaseMouse();
1077 mpDragBox->mbDragging = false;
1078 Application::RemoveAccel( &maAccel );
1079
1080 if ( !bOK )
1081 {
1082 mpDragBox->mnDockLines = mnStartLines;
1083 mpDragBox->EndDocking( maStartRect, false );
1084 }
1085 else
1086 mpDragBox->EndDocking( maRect, false );
1087 mnStartLines = 0;
1088
1089 mpDragBox = nullptr;
1090 }
1091
1092 IMPL_LINK( ImplTBDragMgr, SelectHdl, Accelerator&, rAccel, void )
1093 {
1094 if ( rAccel.GetCurItemId() == KEY_ESCAPE )
1095 EndDragging( false );
1096 else
1097 EndDragging();
1098 }
1099
1100 void ToolBox::ImplInitToolBoxData()
1101 {
1102 // initialize variables
1103 ImplGetWindowImpl()->mbToolBox = true;
1104 mpData.reset(new ImplToolBoxPrivateData);
1105
1106 mpFloatWin = nullptr;
1107 mnDX = 0;
1108 mnDY = 0;
1109 mnMaxItemWidth = 0;
1110 mnMaxItemHeight = 0;
1111 mnWinHeight = 0;
1112 mnLeftBorder = 0;
1113 mnTopBorder = 0;
1114 mnRightBorder = 0;
1115 mnBottomBorder = 0;
1116 mnLastResizeDY = 0;
1117 mnHighItemId = ToolBoxItemId(0);
1118 mnCurItemId = ToolBoxItemId(0);
1119 mnDownItemId = ToolBoxItemId(0);
1120 mnCurPos = ITEM_NOTFOUND;
1121 mnLines = 1;
1122 mnCurLine = 1;
1123 mnCurLines = 1;
1124 mnVisLines = 1;
1125 mnFloatLines = 0;
1126 mnDockLines = 0;
1127 mnMouseModifier = 0;
1128 mbDrag = false;
1129 mbUpper = false;
1130 mbLower = false;
1131 mbIn = false;
1132 mbCalc = true;
1133 mbFormat = false;
1134 mbFullPaint = false;
1135 mbHorz = true;
1136 mbScroll = false;
1137 mbLastFloatMode = false;
1138 mbCustomize = false;
1139 mbDragging = false;
1140 mbIsKeyEvent = false;
1141 mbChangingHighlight = false;
1142 mbLineSpacing = false;
1143 mbIsArranged = false;
1144 meButtonType = ButtonType::SYMBOLONLY;
1145 meAlign = WindowAlign::Top;
1146 meDockAlign = WindowAlign::Top;
1147 meLastStyle = PointerStyle::Arrow;
1148 mnWinStyle = 0;
1149 meLayoutMode = ToolBoxLayoutMode::Normal;
1150 meTextPosition = ToolBoxTextPosition::Right;
1151 mnLastFocusItemId = ToolBoxItemId(0);
1152 mnActivateCount = 0;
1153
1154 mpIdle.reset(new Idle("vcl::ToolBox maIdle update"));
1155 mpIdle->SetPriority( TaskPriority::RESIZE );
1156 mpIdle->SetInvokeHandler( LINK( this, ToolBox, ImplUpdateHdl ) );
1157
1158 // set timeout and handler for dropdown items
1159 mpData->maDropdownTimer.SetTimeout( 250 );
1160 mpData->maDropdownTimer.SetInvokeHandler( LINK( this, ToolBox, ImplDropdownLongClickHdl ) );
1161 }
1162
1163 void ToolBox::ImplInit( vcl::Window* pParent, WinBits nStyle )
1164 {
1165 // initialize variables
1166 mbScroll = (nStyle & WB_SCROLL) != 0;
1167 mnWinStyle = nStyle;
1168
1169 DockingWindow::ImplInit( pParent, nStyle & ~WB_BORDER );
1170
1171 // dockingwindow's ImplInit removes some bits, so restore them here to allow keyboard handling for toolbars
1172 ImplGetWindowImpl()->mnStyle |= WB_TABSTOP|WB_NODIALOGCONTROL; // always set WB_TABSTOP for ToolBars
1173 ImplGetWindowImpl()->mnStyle &= ~WB_DIALOGCONTROL;
1174
1175 ImplInitSettings(true, true, true);
1176 }
1177
1178 void ToolBox::ApplyForegroundSettings(vcl::RenderContext& rRenderContext, const StyleSettings& rStyleSettings)
1179 {
1180 Color aColor;
1181 if (IsControlForeground())
1182 aColor = GetControlForeground();
1183 else if (Window::GetStyle() & WB_3DLOOK)
1184 aColor = rStyleSettings.GetButtonTextColor();
1185 else
1186 aColor = rStyleSettings.GetWindowTextColor();
1187 rRenderContext.SetTextColor(aColor);
1188 rRenderContext.SetTextFillColor();
1189 }
1190
1191 void ToolBox::ApplyBackgroundSettings(vcl::RenderContext& rRenderContext, const StyleSettings& rStyleSettings)
1192 {
1193 if (IsControlBackground())
1194 {
1195 rRenderContext.SetBackground(GetControlBackground());
1196 SetPaintTransparent(false);
1197 SetParentClipMode();
1198 }
1199 else
1200 {
1201 if (rRenderContext.IsNativeControlSupported(ControlType::Toolbar, ControlPart::Entire))
1202 {
1203 rRenderContext.SetBackground();
1204 rRenderContext.SetTextColor(rStyleSettings.GetToolTextColor());
1205 SetPaintTransparent(true);
1206 SetParentClipMode(ParentClipMode::NoClip);
1207 mpData->maDisplayBackground = Wallpaper(rStyleSettings.GetFaceColor());
1208 }
1209 else
1210 {
1211 Color aColor;
1212 if (Window::GetStyle() & WB_3DLOOK)
1213 aColor = rStyleSettings.GetFaceColor();
1214 else
1215 aColor = rStyleSettings.GetWindowColor();
1216 rRenderContext.SetBackground(aColor);
1217 SetPaintTransparent(false);
1218 SetParentClipMode();
1219 }
1220 }
1221 }
1222
1223 void ToolBox::ApplySettings(vcl::RenderContext& rRenderContext)
1224 {
1225 mpData->mbNativeButtons = rRenderContext.IsNativeControlSupported(ControlType::Toolbar, ControlPart::Button);
1226
1227 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
1228
1229 ApplyControlFont(rRenderContext, rStyleSettings.GetToolFont());
1230 ApplyForegroundSettings(rRenderContext, rStyleSettings);
1231 ApplyBackgroundSettings(rRenderContext, rStyleSettings);
1232 }
1233
1234 void ToolBox::ImplInitSettings(bool bFont, bool bForeground, bool bBackground)
1235 {
1236 mpData->mbNativeButtons = IsNativeControlSupported( ControlType::Toolbar, ControlPart::Button );
1237
1238 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1239
1240 if (bFont)
1241 ApplyControlFont(*GetOutDev(), rStyleSettings.GetToolFont());
1242 if (bForeground || bFont)
1243 ApplyForegroundSettings(*GetOutDev(), rStyleSettings);
1244 if (bBackground)
1245 {
1246 ApplyBackgroundSettings(*GetOutDev(), rStyleSettings);
1247 EnableChildTransparentMode(IsPaintTransparent());
1248 }
1249 }
1250
1251 void ToolBox::doDeferredInit(WinBits nBits)
1252 {
1253 VclPtr<vcl::Window> pParent = mpDialogParent;
1254 mpDialogParent = nullptr;
1255 ImplInit(pParent, nBits);
1256 mbIsDeferredInit = false;
1257 }
1258
1259 void ToolBox::queue_resize(StateChangedType eReason)
1260 {
1261 Window::queue_resize(eReason);
1262 }
1263
1264 ToolBox::ToolBox( vcl::Window* pParent, WinBits nStyle ) :
1265 DockingWindow( WindowType::TOOLBOX, "vcl::ToolBox maLayoutIdle" )
1266 {
1267 ImplInitToolBoxData();
1268 ImplInit( pParent, nStyle );
1269 }
1270
1271 ToolBox::ToolBox(vcl::Window* pParent, const OUString& rID,
1272 const OUString& rUIXMLDescription, const css::uno::Reference<css::frame::XFrame> &rFrame)
1273 : DockingWindow(WindowType::TOOLBOX, "vcl::ToolBox maLayoutIdle")
1274 {
1275 ImplInitToolBoxData();
1276
1277 loadUI(pParent, rID, rUIXMLDescription, rFrame);
1278
1279 // calculate size of floating windows and switch if the
1280 // toolbox is initially in floating mode
1281 if ( ImplIsFloatingMode() )
1282 mbHorz = true;
1283 else
1284 Resize();
1285
1286 if (!(GetStyle() & WB_HIDE))
1287 Show();
1288 }
1289
1290 ToolBox::~ToolBox()
1291 {
1292 disposeOnce();
1293 }
1294
1295 void ToolBox::dispose()
1296 {
1297 // #103005# make sure our activate/deactivate balance is right
1298 while( mnActivateCount > 0 )
1299 Deactivate();
1300
1301 // terminate popupmode if the floating window is
1302 // still connected
1303 if ( mpFloatWin )
1304 mpFloatWin->EndPopupMode( FloatWinPopupEndFlags::Cancel );
1305 mpFloatWin = nullptr;
1306
1307 // delete private data
1308 mpData.reset();
1309
1310 ImplSVData* pSVData = ImplGetSVData();
1311 delete pSVData->maCtrlData.mpTBDragMgr;
1312 pSVData->maCtrlData.mpTBDragMgr = nullptr;
1313
1314 mpFloatWin.clear();
1315
1316 mpIdle.reset();
1317
1318 DockingWindow::dispose();
1319 }
1320
1321 ImplToolItem* ToolBox::ImplGetItem( ToolBoxItemId nItemId ) const
1322 {
1323 if (!mpData)
1324 return nullptr;
1325
1326 for (auto & item : mpData->m_aItems)
1327 {
1328 if ( item.mnId == nItemId )
1329 return &item;
1330 }
1331
1332 return nullptr;
1333 }
1334
1335 static void ImplAddButtonBorder( tools::Long &rWidth, tools::Long& rHeight, bool bNativeButtons )
1336 {
1337 rWidth += SMALLBUTTON_HSIZE;
1338 rHeight += SMALLBUTTON_VSIZE;
1339
1340 if( bNativeButtons )
1341 {
1342 // give more border space for rounded buttons
1343 rWidth += 2;
1344 rHeight += 4;
1345 }
1346 }
1347
1348 bool ToolBox::ImplCalcItem()
1349 {
1350 // recalc required ?
1351 if ( !mbCalc )
1352 return false;
1353
1354 OutputDevice *pDefault = Application::GetDefaultDevice();
1355 float fScaleFactor = pDefault ? pDefault->GetDPIScaleFactor() : 1.0;
1356
1357 tools::Long nDefWidth;
1358 tools::Long nDefHeight;
1359 tools::Long nMaxWidth = 0;
1360 tools::Long nMaxHeight = 0;
1361 tools::Long nMinWidth = 6;
1362 tools::Long nMinHeight = 6;
1363 tools::Long nDropDownArrowWidth = TB_DROPDOWNARROWWIDTH * fScaleFactor;
1364 #ifdef IOS
1365 nDropDownArrowWidth *= 3;
1366 #endif
1367
1368 // set defaults if image or text is needed but empty
1369 nDefWidth = GetDefaultImageSize().Width();
1370 nDefHeight = GetDefaultImageSize().Height();
1371
1372 mnWinHeight = 0;
1373 // determine minimum size necessary in NWF
1374 {
1375 tools::Rectangle aRect( Point( 0, 0 ), Size( nMinWidth, nMinHeight ) );
1376 tools::Rectangle aReg( aRect );
1377 ImplControlValue aVal;
1378 tools::Rectangle aNativeBounds, aNativeContent;
1379 if( IsNativeControlSupported( ControlType::Toolbar, ControlPart::Button ) )
1380 {
1381 if( GetNativeControlRegion( ControlType::Toolbar, ControlPart::Button,
1382 aReg,
1383 ControlState::ENABLED | ControlState::ROLLOVER,
1384 aVal,
1385 aNativeBounds, aNativeContent ) )
1386 {
1387 aRect = aNativeBounds;
1388 if( aRect.GetWidth() > nMinWidth )
1389 nMinWidth = aRect.GetWidth();
1390 if( aRect.GetHeight() > nMinHeight )
1391 nMinHeight = aRect.GetHeight();
1392 if( nDropDownArrowWidth < nMinWidth )
1393 nDropDownArrowWidth = nMinWidth;
1394 if( nMinWidth > mpData->mnMenuButtonWidth )
1395 mpData->mnMenuButtonWidth = nMinWidth;
1396 else if( nMinWidth < TB_MENUBUTTON_SIZE )
1397 mpData->mnMenuButtonWidth = TB_MENUBUTTON_SIZE;
1398 }
1399 }
1400
1401 // also calculate the area for comboboxes, drop down list boxes and spinfields
1402 // as these are often inserted into toolboxes; set mnWinHeight to the
1403 // greater of those values to prevent toolbar flickering (#i103385#)
1404 aRect = tools::Rectangle( Point( 0, 0 ), Size( nMinWidth, nMinHeight ) );
1405 aReg = aRect;
1406 if( GetNativeControlRegion( ControlType::Combobox, ControlPart::Entire,
1407 aReg,
1408 ControlState::ENABLED | ControlState::ROLLOVER,
1409 aVal,
1410 aNativeBounds, aNativeContent ) )
1411 {
1412 aRect = aNativeBounds;
1413 if( aRect.GetHeight() > mnWinHeight )
1414 mnWinHeight = aRect.GetHeight();
1415 }
1416 aRect = tools::Rectangle( Point( 0, 0 ), Size( nMinWidth, nMinHeight ) );
1417 aReg = aRect;
1418 if( GetNativeControlRegion( ControlType::Listbox, ControlPart::Entire,
1419 aReg,
1420 ControlState::ENABLED | ControlState::ROLLOVER,
1421 aVal,
1422 aNativeBounds, aNativeContent ) )
1423 {
1424 aRect = aNativeBounds;
1425 if( aRect.GetHeight() > mnWinHeight )
1426 mnWinHeight = aRect.GetHeight();
1427 }
1428 aRect = tools::Rectangle( Point( 0, 0 ), Size( nMinWidth, nMinHeight ) );
1429 aReg = aRect;
1430 if( GetNativeControlRegion( ControlType::Spinbox, ControlPart::Entire,
1431 aReg,
1432 ControlState::ENABLED | ControlState::ROLLOVER,
1433 aVal,
1434 aNativeBounds, aNativeContent ) )
1435 {
1436 aRect = aNativeBounds;
1437 if( aRect.GetHeight() > mnWinHeight )
1438 mnWinHeight = aRect.GetHeight();
1439 }
1440 }
1441
1442 if ( ! mpData->m_aItems.empty() )
1443 {
1444 for (auto & item : mpData->m_aItems)
1445 {
1446 item.mbVisibleText = false; // indicates if text will definitely be drawn, influences dropdown pos
1447
1448 if ( item.meType == ToolBoxItemType::BUTTON )
1449 {
1450 bool bImage;
1451 bool bText;
1452
1453 // check if image and/or text exists
1454 bImage = !!item.maImage;
1455 bText = !item.maText.isEmpty();
1456 ButtonType tmpButtonType = determineButtonType( &item, meButtonType ); // default to toolbox setting
1457 if ( bImage || bText )
1458 {
1459
1460 item.mbEmptyBtn = false;
1461
1462 if ( tmpButtonType == ButtonType::SYMBOLONLY )
1463 {
1464 // we're drawing images only
1465 if ( bImage || !bText )
1466 {
1467 item.maItemSize = item.maImage.GetSizePixel();
1468 }
1469 else
1470 {
1471 item.maItemSize = Size( GetOutDev()->GetCtrlTextWidth( item.maText )+TB_TEXTOFFSET,
1472 GetTextHeight() );
1473 item.mbVisibleText = true;
1474 }
1475 }
1476 else if ( tmpButtonType == ButtonType::TEXT )
1477 {
1478 // we're drawing text only
1479 if ( bText || !bImage )
1480 {
1481 item.maItemSize = Size( GetOutDev()->GetCtrlTextWidth( item.maText )+TB_TEXTOFFSET,
1482 GetTextHeight() );
1483 item.mbVisibleText = true;
1484 }
1485 else
1486 {
1487 item.maItemSize = item.maImage.GetSizePixel();
1488 }
1489 }
1490 else
1491 {
1492 // we're drawing images and text
1493 item.maItemSize.setWidth( bText ? GetOutDev()->GetCtrlTextWidth( item.maText )+TB_TEXTOFFSET : 0 );
1494 item.maItemSize.setHeight( bText ? GetTextHeight() : 0 );
1495
1496 if ( meTextPosition == ToolBoxTextPosition::Right )
1497 {
1498 // leave space between image and text
1499 if( bText )
1500 item.maItemSize.AdjustWidth(TB_IMAGETEXTOFFSET );
1501
1502 // image and text side by side
1503 item.maItemSize.AdjustWidth(item.maImage.GetSizePixel().Width() );
1504 if ( item.maImage.GetSizePixel().Height() > item.maItemSize.Height() )
1505 item.maItemSize.setHeight( item.maImage.GetSizePixel().Height() );
1506 }
1507 else
1508 {
1509 // leave space between image and text
1510 if( bText )
1511 item.maItemSize.AdjustHeight(TB_IMAGETEXTOFFSET );
1512
1513 // text below image
1514 item.maItemSize.AdjustHeight(item.maImage.GetSizePixel().Height() );
1515 if ( item.maImage.GetSizePixel().Width() > item.maItemSize.Width() )
1516 item.maItemSize.setWidth( item.maImage.GetSizePixel().Width() );
1517 }
1518
1519 item.mbVisibleText = bText;
1520 }
1521 }
1522 else
1523 { // no image and no text
1524 item.maItemSize = Size( nDefWidth, nDefHeight );
1525 item.mbEmptyBtn = true;
1526 }
1527
1528 // save the content size
1529 item.maContentSize = item.maItemSize;
1530
1531 // if required, take window height into consideration
1532 if ( item.mpWindow )
1533 {
1534 tools::Long nHeight = item.mpWindow->GetSizePixel().Height();
1535 if ( nHeight > mnWinHeight )
1536 mnWinHeight = nHeight;
1537 }
1538
1539 // add in drop down arrow
1540 if( item.mnBits & ToolBoxItemBits::DROPDOWN )
1541 {
1542 item.maItemSize.AdjustWidth(nDropDownArrowWidth );
1543 item.mnDropDownArrowWidth = nDropDownArrowWidth;
1544 }
1545
1546 // text items will be rotated in vertical mode
1547 // -> swap width and height
1548 if( item.mbVisibleText && !mbHorz )
1549 {
1550 tools::Long tmp = item.maItemSize.Width();
1551 item.maItemSize.setWidth( item.maItemSize.Height() );
1552 item.maItemSize.setHeight( tmp );
1553
1554 tmp = item.maContentSize.Width();
1555 item.maContentSize.setWidth( item.maContentSize.Height() );
1556 item.maContentSize.setHeight( tmp );
1557 }
1558 }
1559 else if ( item.meType == ToolBoxItemType::SPACE )
1560 {
1561 item.maItemSize = Size( nDefWidth, nDefHeight );
1562 item.maContentSize = item.maItemSize;
1563 }
1564
1565 if ( item.meType == ToolBoxItemType::BUTTON || item.meType == ToolBoxItemType::SPACE )
1566 {
1567 // add borders
1568 tools::Long w = item.maItemSize.Width();
1569 tools::Long h = item.maItemSize.Height();
1570 ImplAddButtonBorder( w, h, mpData->mbNativeButtons );
1571 item.maItemSize.setWidth(w);
1572 item.maItemSize.setHeight(h);
1573
1574 if( item.meType == ToolBoxItemType::BUTTON )
1575 {
1576 tools::Long nMinW = std::max(nMinWidth, item.maMinimalItemSize.Width());
1577 tools::Long nMinH = std::max(nMinHeight, item.maMinimalItemSize.Height());
1578
1579 tools::Long nGrowContentWidth = 0;
1580 tools::Long nGrowContentHeight = 0;
1581
1582 if( item.maItemSize.Width() < nMinW )
1583 {
1584 nGrowContentWidth = nMinW - item.maItemSize.Width();
1585 item.maItemSize.setWidth( nMinW );
1586 }
1587 if( item.maItemSize.Height() < nMinH )
1588 {
1589 nGrowContentHeight = nMinH - item.maItemSize.Height();
1590 item.maItemSize.setHeight( nMinH );
1591 }
1592
1593 // grow the content size by the additional available space
1594 item.maContentSize.AdjustWidth(nGrowContentWidth );
1595 item.maContentSize.AdjustHeight(nGrowContentHeight );
1596 }
1597
1598 // keep track of max item size
1599 if ( item.maItemSize.Width() > nMaxWidth )
1600 nMaxWidth = item.maItemSize.Width();
1601 if ( item.maItemSize.Height() > nMaxHeight )
1602 nMaxHeight = item.maItemSize.Height();
1603 }
1604 }
1605 }
1606 else
1607 {
1608 nMaxWidth = nDefWidth;
1609 nMaxHeight = nDefHeight;
1610
1611 ImplAddButtonBorder( nMaxWidth, nMaxHeight, mpData->mbNativeButtons );
1612 }
1613
1614 if( !ImplIsFloatingMode() && GetToolboxButtonSize() != ToolBoxButtonSize::DontCare
1615 && ( meTextPosition == ToolBoxTextPosition::Right ) )
1616 {
1617 // make sure all vertical toolbars have the same width and horizontal have the same height
1618 // this depends on the used button sizes
1619 // as this is used for alignment of multiple toolbars
1620 // it is only required for docked toolbars
1621
1622 tools::Long nFixedWidth = nDefWidth+nDropDownArrowWidth;
1623 tools::Long nFixedHeight = nDefHeight;
1624 ImplAddButtonBorder( nFixedWidth, nFixedHeight, mpData->mbNativeButtons );
1625
1626 if( mbHorz )
1627 nMaxHeight = nFixedHeight;
1628 else
1629 nMaxWidth = nFixedWidth;
1630 }
1631
1632 mbCalc = false;
1633 mbFormat = true;
1634
1635 // do we have to recalc the sizes ?
1636 if ( (nMaxWidth != mnMaxItemWidth) || (nMaxHeight != mnMaxItemHeight) )
1637 {
1638 mnMaxItemWidth = nMaxWidth;
1639 mnMaxItemHeight = nMaxHeight;
1640
1641 return true;
1642 }
1643 else
1644 return false;
1645 }
1646
1647 ToolBox::ImplToolItems::size_type ToolBox::ImplCalcBreaks( tools::Long nWidth, sal_Int32* pMaxLineWidth, bool bCalcHorz ) const
1648 {
1649 sal_uLong nLineStart = 0;
1650 sal_uLong nGroupStart = 0;
1651 tools::Long nLineWidth = 0;
1652 tools::Long nCurWidth;
1653 tools::Long nLastGroupLineWidth = 0;
1654 tools::Long nMaxLineWidth = 0;
1655 ImplToolItems::size_type nLines = 1;
1656 bool bWindow;
1657 bool bBreak = false;
1658 tools::Long nWidthTotal = nWidth;
1659 tools::Long nMenuWidth = 0;
1660
1661 // when docked the menubutton will be in the first line
1662 if( IsMenuEnabled() && !ImplIsFloatingMode() )
1663 nMenuWidth = mpData->maMenubuttonItem.maItemSize.Width();
1664
1665 // we need to know which item is the last visible one to be able to add
1666 // the menu width in case we are unable to show all the items
1667 ImplToolItems::iterator it, lastVisible;
1668 for ( it = mpData->m_aItems.begin(); it != mpData->m_aItems.end(); ++it )
1669 {
1670 if ( it->mbVisible )
1671 lastVisible = it;
1672 }
1673
1674 it = mpData->m_aItems.begin();
1675 while ( it != mpData->m_aItems.end() )
1676 {
1677 it->mbBreak = bBreak;
1678 bBreak = false;
1679
1680 if ( it->mbVisible )
1681 {
1682 bWindow = false;
1683 bBreak = false;
1684 nCurWidth = 0;
1685
1686 if ( it->meType == ToolBoxItemType::BUTTON || it->meType == ToolBoxItemType::SPACE )
1687 {
1688 if ( bCalcHorz )
1689 nCurWidth = it->maItemSize.Width();
1690 else
1691 nCurWidth = it->maItemSize.Height();
1692
1693 if ( it->mpWindow && bCalcHorz )
1694 {
1695 tools::Long nWinItemWidth = it->mpWindow->GetSizePixel().Width();
1696 if ( !mbScroll || (nWinItemWidth <= nWidthTotal) )
1697 {
1698 nCurWidth = nWinItemWidth;
1699 bWindow = true;
1700 }
1701 else
1702 {
1703 if ( it->mbEmptyBtn )
1704 {
1705 nCurWidth = 0;
1706 }
1707 }
1708 }
1709
1710 // in case we are able to show all the items, we do not want
1711 // to show the toolbar's menu; otherwise yes
1712 if ( ( ( it == lastVisible ) && (nLineWidth+nCurWidth > nWidthTotal) && mbScroll ) ||
1713 ( ( it != lastVisible ) && (nLineWidth+nCurWidth+nMenuWidth > nWidthTotal) && mbScroll ) )
1714 bBreak = true;
1715 }
1716 else if ( it->meType == ToolBoxItemType::SEPARATOR )
1717 {
1718 nCurWidth = it->mnSepSize;
1719 if ( !ImplIsFloatingMode() && ( it != lastVisible ) && (nLineWidth+nCurWidth+nMenuWidth > nWidthTotal) )
1720 bBreak = true;
1721 }
1722 // treat breaks as separators, except when using old style toolbars (ie. no menu button)
1723 else if ( (it->meType == ToolBoxItemType::BREAK) && !IsMenuEnabled() )
1724 bBreak = true;
1725
1726 if ( bBreak )
1727 {
1728 nLines++;
1729
1730 // Add break before the entire group or take group apart?
1731 if ( (it->meType == ToolBoxItemType::BREAK) ||
1732 (nLineStart == nGroupStart) )
1733 {
1734 if ( nLineWidth > nMaxLineWidth )
1735 nMaxLineWidth = nLineWidth;
1736
1737 nLineWidth = 0;
1738 nLineStart = it - mpData->m_aItems.begin();
1739 nGroupStart = nLineStart;
1740 it->mbBreak = true;
1741 bBreak = false;
1742 }
1743 else
1744 {
1745 if ( nLastGroupLineWidth > nMaxLineWidth )
1746 nMaxLineWidth = nLastGroupLineWidth;
1747
1748 // if the break is added before the group, set it to
1749 // beginning of line and re-calculate
1750 nLineWidth = 0;
1751 nLineStart = nGroupStart;
1752 it = mpData->m_aItems.begin() + nGroupStart;
1753 continue;
1754 }
1755 }
1756 else
1757 {
1758 if( ImplIsFloatingMode() || !IsMenuEnabled() ) // no group breaking when being docked single-line
1759 {
1760 if ( (it->meType != ToolBoxItemType::BUTTON) || bWindow )
1761 {
1762 // found separator or break
1763 nLastGroupLineWidth = nLineWidth;
1764 nGroupStart = it - mpData->m_aItems.begin();
1765 if ( !bWindow )
1766 nGroupStart++;
1767 }
1768 }
1769 }
1770
1771 nLineWidth += nCurWidth;
1772 }
1773
1774 ++it;
1775 }
1776
1777 if ( pMaxLineWidth )
1778 {
1779 if ( nLineWidth > nMaxLineWidth )
1780 nMaxLineWidth = nLineWidth;
1781
1782 if( ImplIsFloatingMode() && !ImplIsInPopupMode() )
1783 {
1784 // leave enough space to display buttons in the decoration
1785 tools::Long aMinWidth = 2 * GetSettings().GetStyleSettings().GetFloatTitleHeight();
1786 if( nMaxLineWidth < aMinWidth )
1787 nMaxLineWidth = aMinWidth;
1788 }
1789 *pMaxLineWidth = nMaxLineWidth;
1790 }
1791
1792 return nLines;
1793 }
1794
1795 Size ToolBox::ImplGetOptimalFloatingSize()
1796 {
1797 if( !ImplIsFloatingMode() )
1798 return Size();
1799
1800 Size aCurrentSize( mnDX, mnDY );
1801 Size aSize1( aCurrentSize );
1802 Size aSize2( aCurrentSize );
1803
1804 // try to preserve current height
1805
1806 // calc number of floating lines for current window height
1807 ImplToolItems::size_type nFloatLinesHeight = ImplCalcLines( mnDY );
1808 // calc window size according to this number
1809 aSize1 = ImplCalcFloatSize( nFloatLinesHeight );
1810
1811 if( aCurrentSize == aSize1 )
1812 return aSize1;
1813
1814 // try to preserve current width
1815
1816 tools::Long nLineHeight = std::max( mnWinHeight, mnMaxItemHeight );
1817 int nBorderX = 2*TB_BORDER_OFFSET1 + mnLeftBorder + mnRightBorder;
1818 int nBorderY = 2*TB_BORDER_OFFSET2 + mnTopBorder + mnBottomBorder;
1819 Size aSz( aCurrentSize );
1820 sal_Int32 maxX;
1821 ImplToolItems::size_type nLines = ImplCalcBreaks( aSz.Width()-nBorderX, &maxX, mbHorz );
1822
1823 ImplToolItems::size_type manyLines = 1000;
1824 Size aMinimalFloatSize = ImplCalcFloatSize( manyLines );
1825
1826 aSz.setHeight( nBorderY + nLineHeight * nLines );
1827 // line space when more than one line
1828 if ( mbLineSpacing )
1829 aSz.AdjustHeight((nLines-1)*TB_LINESPACING );
1830
1831 aSz.setWidth( nBorderX + maxX );
1832
1833 // avoid clipping of any items
1834 if( aSz.Width() < aMinimalFloatSize.Width() )
1835 aSize2 = ImplCalcFloatSize( nLines );
1836 else
1837 aSize2 = aSz;
1838
1839 if( aCurrentSize == aSize2 )
1840 return aSize2;
1841
1842 // set the size with the smallest delta as the current size
1843 tools::Long dx1 = std::abs( mnDX - aSize1.Width() );
1844 tools::Long dy1 = std::abs( mnDY - aSize1.Height() );
1845
1846 tools::Long dx2 = std::abs( mnDX - aSize2.Width() );
1847 tools::Long dy2 = std::abs( mnDY - aSize2.Height() );
1848
1849 if( dx1*dy1 < dx2*dy2 )
1850 aCurrentSize = aSize1;
1851 else
1852 aCurrentSize = aSize2;
1853
1854 return aCurrentSize;
1855 }
1856
1857 namespace
1858 {
1859 void lcl_hideDoubleSeparators( ToolBox::ImplToolItems& rItems )
1860 {
1861 bool bLastSep( true );
1862 ToolBox::ImplToolItems::iterator it;
1863 for ( it = rItems.begin(); it != rItems.end(); ++it )
1864 {
1865 if ( it->meType == ToolBoxItemType::SEPARATOR )
1866 {
1867 it->mbVisible = false;
1868 if ( !bLastSep )
1869 {
1870 // check if any visible items have to appear behind it
1871 if (std::any_of(it + 1, rItems.end(), [](const ImplToolItem& rItem) {
1872 return (rItem.meType == ToolBoxItemType::BUTTON) && rItem.mbVisible; }))
1873 it->mbVisible = true;
1874 }
1875 bLastSep = true;
1876 }
1877 else if ( it->mbVisible )
1878 bLastSep = false;
1879 }
1880 }
1881 }
1882
1883 void ToolBox::ImplFormat( bool bResize )
1884 {
1885 // Has to re-formatted
1886 if ( !mbFormat )
1887 return;
1888
1889 mpData->ImplClearLayoutData();
1890
1891 // recalculate positions and sizes
1892 tools::Rectangle aEmptyRect;
1893 tools::Long nLineSize;
1894 tools::Long nLeft;
1895 tools::Long nTop;
1896 tools::Long nMax; // width of layoutarea in pixels
1897 ImplToolItems::size_type nFormatLine;
1898 bool bMustFullPaint;
1899
1900 ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
1901 bool bIsInPopupMode = ImplIsInPopupMode();
1902
1903 maFloatSizes.clear();
1904
1905 // compute border sizes
1906 ImplCalcBorder( meAlign, mnLeftBorder, mnTopBorder, mnRightBorder, mnBottomBorder );
1907
1908 // update drag area (where the 'grip' will be placed)
1909 tools::Rectangle aOldDragRect;
1910 if( pWrapper )
1911 aOldDragRect = pWrapper->GetDragArea();
1912 ImplUpdateDragArea();
1913
1914 bMustFullPaint = ImplCalcItem();
1915
1916 // calculate new size during interactive resize or
1917 // set computed size when formatting only
1918 if ( ImplIsFloatingMode() )
1919 {
1920 if ( bResize )
1921 mnFloatLines = ImplCalcLines( mnDY );
1922 else
1923 SetOutputSizePixel( ImplGetOptimalFloatingSize() );
1924 }
1925
1926 // Horizontal
1927 if ( mbHorz )
1928 {
1929 tools::Long nBottom;
1930 // nLineSize: height of a single line, will fit highest item
1931 nLineSize = mnMaxItemHeight;
1932
1933 if ( mnWinHeight > mnMaxItemHeight )
1934 nLineSize = mnWinHeight;
1935
1936 if ( mbScroll )
1937 {
1938 nMax = mnDX;
1939 mnVisLines = ImplCalcLines( mnDY );
1940 }
1941 else
1942 {
1943 // layout over all lines
1944 mnVisLines = mnLines;
1945 nMax = TB_MAXNOSCROLL;
1946 }
1947
1948 // add in all border offsets
1949 if ( mnWinStyle & WB_BORDER )
1950 {
1951 nLeft = TB_BORDER_OFFSET1 + mnLeftBorder;
1952 nTop = TB_BORDER_OFFSET2 + mnTopBorder;
1953 nBottom = TB_BORDER_OFFSET1 + mnBottomBorder;
1954 nMax -= nLeft + TB_BORDER_OFFSET1 + mnRightBorder;
1955 }
1956 else
1957 {
1958 nLeft = 0;
1959 nTop = 0;
1960 nBottom = 0;
1961 }
1962
1963 // adjust linesize if docked in single-line mode (i.e. when using a clipped item menu)
1964 // we have to center all items in the window height
1965 if( IsMenuEnabled() && !ImplIsFloatingMode() )
1966 {
1967 tools::Long nWinHeight = mnDY - nTop - nBottom;
1968 if( nWinHeight > nLineSize )
1969 nLineSize = nWinHeight;
1970 }
1971 }
1972 else
1973 {
1974 tools::Long nRight;
1975 nLineSize = mnMaxItemWidth;
1976
1977 if ( mbScroll )
1978 {
1979 mnVisLines = ImplCalcLines( mnDX );
1980 nMax = mnDY;
1981 }
1982 else
1983 {
1984 mnVisLines = mnLines;
1985 nMax = TB_MAXNOSCROLL;
1986 }
1987
1988 if ( mnWinStyle & WB_BORDER )
1989 {
1990 nTop = TB_BORDER_OFFSET1 + mnTopBorder;
1991 nLeft = TB_BORDER_OFFSET2 + mnLeftBorder;
1992 nRight = TB_BORDER_OFFSET2 + mnRightBorder;
1993 nMax -= nTop + TB_BORDER_OFFSET1 + mnBottomBorder;
1994 }
1995 else
1996 {
1997 nLeft = 0;
1998 nTop = 0;
1999 nRight = 0;
2000 }
2001
2002 // adjust linesize if docked in single-line mode (i.e. when using a clipped item menu)
2003 // we have to center all items in the window height
2004 if( !ImplIsFloatingMode() && IsMenuEnabled() )
2005 {
2006 tools::Long nWinWidth = mnDX - nLeft - nRight;
2007 if( nWinWidth > nLineSize )
2008 nLineSize = nWinWidth;
2009 }
2010 }
2011
2012 // no calculation if the window has no size (nMax=0)
2013 // non scrolling toolboxes must be computed though
2014 if ( (nMax <= 0) && mbScroll )
2015 {
2016 mnVisLines = 1;
2017 mnCurLine = 1;
2018 mnCurLines = 1;
2019
2020 for (auto & item : mpData->m_aItems)
2021 {
2022 item.maRect = aEmptyRect;
2023 }
2024
2025 maLowerRect = aEmptyRect;
2026 maUpperRect = aEmptyRect;
2027 }
2028 else
2029 {
2030 // init start values
2031 tools::Long nX = nLeft; // top-left offset
2032 tools::Long nY = nTop;
2033 nFormatLine = 1;
2034
2035 // save old scroll rectangles and reset them
2036 tools::Rectangle aOldLowerRect = maLowerRect;
2037 tools::Rectangle aOldUpperRect = maUpperRect;
2038 tools::Rectangle aOldMenubuttonRect = mpData->maMenubuttonItem.maRect;
2039 maUpperRect = aEmptyRect;
2040 maLowerRect = aEmptyRect;
2041 mpData->maMenubuttonItem.maRect = aEmptyRect;
2042
2043 // do we have any toolbox items at all ?
2044 if ( !mpData->m_aItems.empty() || IsMenuEnabled() )
2045 {
2046 lcl_hideDoubleSeparators( mpData->m_aItems );
2047
2048 // compute line breaks and visible lines give the current window width (nMax)
2049 // the break indicators will be stored within each item (it->mbBreak)
2050 mnCurLines = ImplCalcBreaks( nMax, nullptr, mbHorz );
2051
2052 // check for scrollbar buttons or dropdown menu
2053 // (if a menu is enabled, this will be used to store clipped
2054 // items and no scroll buttons will appear)
2055 if ( (!ImplIsFloatingMode() && (mnCurLines > mnVisLines) && mbScroll ) ||
2056 IsMenuEnabled() )
2057 {
2058 // compute linebreaks again, incorporating scrollbar buttons
2059 if( !IsMenuEnabled() )
2060 {
2061 nMax -= TB_SPIN_SIZE+TB_SPIN_OFFSET;
2062 mnCurLines = ImplCalcBreaks( nMax, nullptr, mbHorz );
2063 }
2064
2065 // compute scroll rectangles or menu button
2066 if ( mbHorz )
2067 {
2068 if( IsMenuEnabled() && !ImplHasExternalMenubutton() && !bIsInPopupMode )
2069 {
2070 if( !ImplIsFloatingMode() )
2071 {
2072 mpData->maMenubuttonItem.maRect.SetRight( mnDX - 2 );
2073 mpData->maMenubuttonItem.maRect.SetTop( nTop );
2074 mpData->maMenubuttonItem.maRect.SetBottom( mnDY-mnBottomBorder-TB_BORDER_OFFSET2-1 );
2075 }
2076 else
2077 {
2078 mpData->maMenubuttonItem.maRect.SetRight( mnDX - mnRightBorder-TB_BORDER_OFFSET1-1 );
2079 mpData->maMenubuttonItem.maRect.SetTop( nTop );
2080 mpData->maMenubuttonItem.maRect.SetBottom( mnDY-mnBottomBorder-TB_BORDER_OFFSET2-1 );
2081 }
2082 mpData->maMenubuttonItem.maRect.SetLeft( mpData->maMenubuttonItem.maRect.Right() - mpData->mnMenuButtonWidth );
2083 }
2084 else
2085 {
2086 maUpperRect.SetLeft( nLeft+nMax+TB_SPIN_OFFSET );
2087 maUpperRect.SetRight( maUpperRect.Left()+TB_SPIN_SIZE-1 );
2088 maUpperRect.SetTop( nTop );
2089 maLowerRect.SetBottom( mnDY-mnBottomBorder-TB_BORDER_OFFSET2-1 );
2090 maLowerRect.SetLeft( maUpperRect.Left() );
2091 maLowerRect.SetRight( maUpperRect.Right() );
2092 maUpperRect.SetBottom( maUpperRect.Top() +
2093 (maLowerRect.Bottom()-maUpperRect.Top())/2 );
2094 maLowerRect.SetTop( maUpperRect.Bottom() );
2095 }
2096 }
2097 else
2098 {
2099 if( IsMenuEnabled() && !ImplHasExternalMenubutton() && !bIsInPopupMode )
2100 {
2101 if( !ImplIsFloatingMode() )
2102 {
2103 mpData->maMenubuttonItem.maRect.SetBottom( mnDY - 2 );
2104 mpData->maMenubuttonItem.maRect.SetLeft( nLeft );
2105 mpData->maMenubuttonItem.maRect.SetRight( mnDX-mnRightBorder-TB_BORDER_OFFSET2-1 );
2106 }
2107 else
2108 {
2109 mpData->maMenubuttonItem.maRect.SetBottom( mnDY - mnBottomBorder-TB_BORDER_OFFSET1-1 );
2110 mpData->maMenubuttonItem.maRect.SetLeft( nLeft );
2111 mpData->maMenubuttonItem.maRect.SetRight( mnDX-mnRightBorder-TB_BORDER_OFFSET2-1 );
2112 }
2113 mpData->maMenubuttonItem.maRect.SetTop( mpData->maMenubuttonItem.maRect.Bottom() - mpData->mnMenuButtonWidth );
2114 }
2115 else
2116 {
2117 maUpperRect.SetTop( nTop+nMax+TB_SPIN_OFFSET );
2118 maUpperRect.SetBottom( maUpperRect.Top()+TB_SPIN_SIZE-1 );
2119 maUpperRect.SetLeft( nLeft );
2120 maLowerRect.SetRight( mnDX-mnRightBorder-TB_BORDER_OFFSET2-1 );
2121 maLowerRect.SetTop( maUpperRect.Top() );
2122 maLowerRect.SetBottom( maUpperRect.Bottom() );
2123 maUpperRect.SetRight( maUpperRect.Left() +
2124 (maLowerRect.Right()-maUpperRect.Left())/2 );
2125 maLowerRect.SetLeft( maUpperRect.Right() );
2126 }
2127 }
2128 }
2129
2130 // no scrolling when there is a "more"-menu
2131 // anything will "fit" in a single line then
2132 if( IsMenuEnabled() )
2133 mnCurLines = 1;
2134
2135 // determine the currently visible line
2136 if ( mnVisLines >= mnCurLines )
2137 mnCurLine = 1;
2138 else if ( mnCurLine+mnVisLines-1 > mnCurLines )
2139 mnCurLine = mnCurLines - (mnVisLines-1);
2140
2141 tools::Long firstItemCenter = 0;
2142 for (auto & item : mpData->m_aItems)
2143 {
2144 item.mbShowWindow = false;
2145
2146 // check for line break and advance nX/nY accordingly
2147 if ( item.mbBreak )
2148 {
2149 nFormatLine++;
2150
2151 // increment starting with the second line
2152 if ( nFormatLine > mnCurLine )
2153 {
2154 if ( mbHorz )
2155 {
2156 nX = nLeft;
2157 if ( mbLineSpacing )
2158 nY += nLineSize+TB_LINESPACING;
2159 else
2160 nY += nLineSize;
2161 }
2162 else
2163 {
2164 nY = nTop;
2165 if ( mbLineSpacing )
2166 nX += nLineSize+TB_LINESPACING;
2167 else
2168 nX += nLineSize;
2169 }
2170 }
2171 }
2172
2173 if ( !item.mbVisible || (nFormatLine < mnCurLine) ||
2174 (nFormatLine > mnCurLine+mnVisLines-1) )
2175 // item is not visible
2176 item.maCalcRect = aEmptyRect;
2177 else
2178 {
2179 // 1. determine current item width/height
2180 // take window size and orientation into account, because this affects the size of item windows
2181
2182 Size aCurrentItemSize( item.GetSize( mbHorz, mbScroll, nMax, Size(mnMaxItemWidth, mnMaxItemHeight) ) );
2183
2184 // 2. position item rect and use size from step 1
2185 // items will be centered horizontally (if mbHorz) or vertically
2186 // advance nX and nY accordingly
2187
2188 if ( mbHorz )
2189 {
2190 // In special mode Locked horizontal positions of all items remain unchanged.
2191
2192 if ( mbIsArranged && meLayoutMode == ToolBoxLayoutMode::Locked && mnLines == 1 && item.maRect.Left() > 0 )
2193 nX = item.maRect.Left();
2194 item.maCalcRect.SetLeft( nX );
2195
2196 // In special mode Locked first item's vertical position remains unchanged. Consecutive items vertical
2197 // positions are centered around first item's vertical position. If an item's height exceeds available
2198 // space, item's vertical position remains unchanged too.
2199
2200 if ( mbIsArranged && meLayoutMode == ToolBoxLayoutMode::Locked && mnLines == 1 )
2201 if ( firstItemCenter > 0 )
2202 if ( firstItemCenter-aCurrentItemSize.Height()/2 > nY )
2203 item.maCalcRect.SetTop( firstItemCenter-aCurrentItemSize.Height()/2 );
2204 else
2205 item.maCalcRect.SetTop( item.maRect.Top() );
2206 else
2207 {
2208 item.maCalcRect.SetTop( item.maRect.Top() );
2209 firstItemCenter = item.maRect.Top()+aCurrentItemSize.Height()/2;
2210 }
2211 else
2212 item.maCalcRect.SetTop( nY+(nLineSize-aCurrentItemSize.Height())/2 );
2213 item.maCalcRect.SetRight( nX+aCurrentItemSize.Width()-1 );
2214 item.maCalcRect.SetBottom( item.maCalcRect.Top()+aCurrentItemSize.Height()-1 );
2215 nX += aCurrentItemSize.Width();
2216 }
2217 else
2218 {
2219 item.maCalcRect.SetLeft( nX+(nLineSize-aCurrentItemSize.Width())/2 );
2220 item.maCalcRect.SetTop( nY );
2221 item.maCalcRect.SetRight( item.maCalcRect.Left()+aCurrentItemSize.Width()-1 );
2222 item.maCalcRect.SetBottom( nY+aCurrentItemSize.Height()-1 );
2223 nY += aCurrentItemSize.Height();
2224 }
2225 }
2226
2227 // position window items into calculated item rect
2228 if ( item.mpWindow )
2229 {
2230 if ( item.mbShowWindow )
2231 {
2232 Point aPos( item.maCalcRect.Left(), item.maCalcRect.Top() );
2233
2234 assert( item.maCalcRect.Top() >= 0 );
2235
2236 item.mpWindow->SetPosPixel( aPos );
2237 item.mpWindow->Show();
2238 }
2239 else
2240 item.mpWindow->Hide();
2241 }
2242 } // end of loop over all items
2243 mbIsArranged = true;
2244 }
2245 else
2246 // we have no toolbox items
2247 mnCurLines = 1;
2248
2249 if( IsMenuEnabled() && ImplIsFloatingMode() && !ImplHasExternalMenubutton() && !bIsInPopupMode )
2250 {
2251 // custom menu will be the last button in floating mode
2252 ImplToolItem &rIt = mpData->maMenubuttonItem;
2253
2254 if ( mbHorz )
2255 {
2256 rIt.maRect.SetLeft( nX+TB_MENUBUTTON_OFFSET );
2257 rIt.maRect.SetTop( nY );
2258 rIt.maRect.SetRight( rIt.maRect.Left() + mpData->mnMenuButtonWidth );
2259 rIt.maRect.SetBottom( nY+nLineSize-1 );
2260 nX += rIt.maItemSize.Width();
2261 }
2262 else
2263 {
2264 rIt.maRect.SetLeft( nX );
2265 rIt.maRect.SetTop( nY+TB_MENUBUTTON_OFFSET );
2266 rIt.maRect.SetRight( nX+nLineSize-1 );
2267 rIt.maRect.SetBottom( rIt.maRect.Top() + mpData->mnMenuButtonWidth );
2268 nY += rIt.maItemSize.Height();
2269 }
2270 }
2271
2272 // if toolbox visible trigger paint for changed regions
2273 if ( IsVisible() && !mbFullPaint )
2274 {
2275 if ( bMustFullPaint )
2276 {
2277 maPaintRect = tools::Rectangle( mnLeftBorder, mnTopBorder,
2278 mnDX-mnRightBorder, mnDY-mnBottomBorder );
2279 }
2280 else
2281 {
2282 if ( aOldLowerRect != maLowerRect )
2283 {
2284 maPaintRect.Union( maLowerRect );
2285 maPaintRect.Union( aOldLowerRect );
2286 }
2287 if ( aOldUpperRect != maUpperRect )
2288 {
2289 maPaintRect.Union( maUpperRect );
2290 maPaintRect.Union( aOldUpperRect );
2291 }
2292 if ( aOldMenubuttonRect != mpData->maMenubuttonItem.maRect )
2293 {
2294 maPaintRect.Union( mpData->maMenubuttonItem.maRect );
2295 maPaintRect.Union( aOldMenubuttonRect );
2296 }
2297 if ( pWrapper && aOldDragRect != pWrapper->GetDragArea() )
2298 {
2299 maPaintRect.Union( pWrapper->GetDragArea() );
2300 maPaintRect.Union( aOldDragRect );
2301 }
2302
2303 for (auto const& item : mpData->m_aItems)
2304 {
2305 if ( item.maRect != item.maCalcRect )
2306 {
2307 maPaintRect.Union( item.maRect );
2308 maPaintRect.Union( item.maCalcRect );
2309 }
2310 }
2311 }
2312
2313 Invalidate( maPaintRect );
2314 }
2315
2316 // store the new calculated item rects
2317 maPaintRect = aEmptyRect;
2318 for (auto & item : mpData->m_aItems)
2319 item.maRect = item.maCalcRect;
2320 }
2321
2322 // indicate formatting is done
2323 mbFormat = false;
2324 }
2325
2326 IMPL_LINK_NOARG(ToolBox, ImplDropdownLongClickHdl, Timer *, void)
2327 {
2328 if (mnCurPos == ITEM_NOTFOUND ||
2329 !(mpData->m_aItems[ mnCurPos ].mnBits & ToolBoxItemBits::DROPDOWN))
2330 return;
2331
2332 mpData->mbDropDownByKeyboard = false;
2333 mpData->maDropdownClickHdl.Call( this );
2334
2335 // do not reset data if the dropdown handler opened a floating window
2336 // see ImplFloatControl()
2337 if( !mpFloatWin )
2338 {
2339 // no floater was opened
2340 Deactivate();
2341 InvalidateItem(mnCurPos);
2342
2343 mnCurPos = ITEM_NOTFOUND;
2344 mnCurItemId = ToolBoxItemId(0);
2345 mnDownItemId = ToolBoxItemId(0);
2346 mnMouseModifier = 0;
2347 mnHighItemId = ToolBoxItemId(0);
2348 }
2349 }
2350
2351 IMPL_LINK_NOARG(ToolBox, ImplUpdateHdl, Timer *, void)
2352 {
2353
2354 if( mbFormat && mpData )
2355 ImplFormat();
2356 }
2357
2358 static void ImplDrawMoreIndicator(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
2359 {
2360 const Image pImage(StockImage::Yes, CHEVRON);
2361 Size aImageSize = pImage.GetSizePixel();
2362 tools::Long x = rRect.Left() + (rRect.getOpenWidth() - aImageSize.Width())/2;
2363 tools::Long y = rRect.Top() + (rRect.getOpenHeight() - aImageSize.Height())/2;
2364 DrawImageFlags nImageStyle = DrawImageFlags::NONE;
2365
2366 rRenderContext.DrawImage(Point(x,y), pImage, nImageStyle);
2367 }
2368
2369 static void ImplDrawDropdownArrow(vcl::RenderContext& rRenderContext, const tools::Rectangle& rDropDownRect, bool bSetColor, bool bRotate )
2370 {
2371 bool bLineColor = rRenderContext.IsLineColor();
2372 bool bFillColor = rRenderContext.IsFillColor();
2373 Color aOldFillColor = rRenderContext.GetFillColor();
2374 Color aOldLineColor = rRenderContext.GetLineColor();
2375 rRenderContext.SetLineColor();
2376
2377 if ( bSetColor )
2378 {
2379 if (rRenderContext.GetSettings().GetStyleSettings().GetFaceColor().IsDark())
2380 rRenderContext.SetFillColor(COL_WHITE);
2381 else
2382 rRenderContext.SetFillColor(COL_BLACK);
2383 }
2384
2385 tools::Polygon aPoly(4);
2386
2387 // the assumption is, that the width always specifies the size of the expected arrow.
2388 const tools::Long nMargin = round(2 * rRenderContext.GetDPIScaleFactor());
2389 const tools::Long nSize = rDropDownRect.getOpenWidth() - 2 * nMargin;
2390 const tools::Long nHalfSize = (nSize + 1) / 2;
2391 const tools::Long x = rDropDownRect.Left() + nMargin + (bRotate ? (rDropDownRect.getOpenWidth() - nHalfSize) / 2 : 0);
2392 const tools::Long y = rDropDownRect.Top() + nMargin + (rDropDownRect.getOpenHeight() - (bRotate ? nSize : nHalfSize)) / 2;
2393
2394 aPoly.SetPoint(Point(x, y), 0);
2395 if (bRotate) // >
2396 {
2397 aPoly.SetPoint(Point(x, y + nSize), 1);
2398 aPoly.SetPoint(Point(x + nHalfSize, y + nHalfSize), 2);
2399 }
2400 else // v
2401 {
2402 aPoly.SetPoint(Point(x + nHalfSize, y + nHalfSize), 1);
2403 aPoly.SetPoint(Point(x + nSize, y), 2);
2404 }
2405 aPoly.SetPoint(Point(x, y), 3);
2406
2407 auto aaflags = rRenderContext.GetAntialiasing();
2408 rRenderContext.SetAntialiasing(AntialiasingFlags::Enable);
2409 rRenderContext.DrawPolygon( aPoly );
2410 rRenderContext.SetAntialiasing(aaflags);
2411
2412 if( bFillColor )
2413 rRenderContext.SetFillColor(aOldFillColor);
2414 else
2415 rRenderContext.SetFillColor();
2416 if( bLineColor )
2417 rRenderContext.SetLineColor(aOldLineColor);
2418 else
2419 rRenderContext.SetLineColor();
2420 }
2421
2422 void ToolBox::ImplDrawMenuButton(vcl::RenderContext& rRenderContext, bool bHighlight)
2423 {
2424 if (mpData->maMenubuttonItem.maRect.IsEmpty())
2425 return;
2426
2427 // #i53937# paint menu button only if necessary
2428 if (!ImplHasClippedItems())
2429 return;
2430
2431 // execute pending paint requests
2432 ImplCheckUpdate();
2433
2434 rRenderContext.Push(vcl::PushFlags::FILLCOLOR | vcl::PushFlags::LINECOLOR);
2435
2436 // draw the 'more' indicator / button (>>)
2437 ImplErase(rRenderContext, mpData->maMenubuttonItem.maRect, bHighlight);
2438
2439 if (bHighlight)
2440 ImplDrawButton(rRenderContext, mpData->maMenubuttonItem.maRect, 2, false, true, false );
2441
2442 if (ImplHasClippedItems())
2443 ImplDrawMoreIndicator(rRenderContext, mpData->maMenubuttonItem.maRect);
2444
2445 // store highlight state
2446 mpData->mbMenubuttonSelected = bHighlight;
2447
2448 // restore colors
2449 rRenderContext.Pop();
2450 }
2451
2452 void ToolBox::ImplDrawSpin(vcl::RenderContext& rRenderContext)
2453 {
2454 bool bTmpUpper;
2455 bool bTmpLower;
2456
2457 if ( maUpperRect.IsEmpty() || maLowerRect.IsEmpty() )
2458 return;
2459
2460 bTmpUpper = mnCurLine > 1;
2461
2462 bTmpLower = mnCurLine+mnVisLines-1 < mnCurLines;
2463
2464 if ( !IsEnabled() )
2465 {
2466 bTmpUpper = false;
2467 bTmpLower = false;
2468 }
2469
2470 ImplDrawUpDownButtons(rRenderContext, maUpperRect, maLowerRect,
2471 false/*bUpperIn*/, false/*bLowerIn*/, bTmpUpper, bTmpLower, !mbHorz);
2472 }
2473
2474 void ToolBox::ImplDrawSeparator(vcl::RenderContext& rRenderContext, ImplToolItems::size_type nPos, const tools::Rectangle& rRect)
2475 {
2476 if ( nPos >= mpData->m_aItems.size() - 1 )
2477 // no separator if it's the last item
2478 return;
2479
2480 ImplToolItem* pItem = &mpData->m_aItems[nPos];
2481 ImplToolItem* pPreviousItem = &mpData->m_aItems[nPos-1];
2482 ImplToolItem* pNextItem = &mpData->m_aItems[nPos+1];
2483
2484 if ( ( pPreviousItem->mbShowWindow && pNextItem->mbShowWindow ) || pNextItem->mbBreak )
2485 // no separator between two windows or before a break
2486 return;
2487
2488 bool bNativeOk = false;
2489 ControlPart nPart = IsHorizontal() ? ControlPart::SeparatorVert : ControlPart::SeparatorHorz;
2490 if (rRenderContext.IsNativeControlSupported(ControlType::Toolbar, nPart))
2491 {
2492 ImplControlValue aControlValue;
2493 bNativeOk = rRenderContext.DrawNativeControl(ControlType::Toolbar, nPart, rRect, ControlState::NONE, aControlValue, OUString());
2494 }
2495
2496 /* Draw the widget only if it can't be drawn natively. */
2497 if (bNativeOk)
2498 return;
2499
2500 tools::Long nCenterPos, nSlim;
2501 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
2502 rRenderContext.SetLineColor(rStyleSettings.GetSeparatorColor());
2503 if (IsHorizontal())
2504 {
2505 nSlim = (pItem->maRect.Bottom() - pItem->maRect.Top ()) / 4;
2506 nCenterPos = pItem->maRect.Center().X();
2507 rRenderContext.DrawLine(Point(nCenterPos, pItem->maRect.Top() + nSlim),
2508 Point(nCenterPos, pItem->maRect.Bottom() - nSlim));
2509 }
2510 else
2511 {
2512 nSlim = (pItem->maRect.Right() - pItem->maRect.Left ()) / 4;
2513 nCenterPos = pItem->maRect.Center().Y();
2514 rRenderContext.DrawLine(Point(pItem->maRect.Left() + nSlim, nCenterPos),
2515 Point(pItem->maRect.Right() - nSlim, nCenterPos));
2516 }
2517 }
2518
2519 void ToolBox::ImplDrawButton(vcl::RenderContext& rRenderContext, const tools::Rectangle &rRect, sal_uInt16 highlight,
2520 bool bChecked, bool bEnabled, bool bIsWindow )
2521 {
2522 // draws toolbar button background either native or using a coloured selection
2523 // if bIsWindow is true, the corresponding item is a control and only a selection border will be drawn
2524
2525 bool bNativeOk = false;
2526 if( !bIsWindow && rRenderContext.IsNativeControlSupported( ControlType::Toolbar, ControlPart::Button ) )
2527 {
2528 ImplControlValue aControlValue;
2529 ControlState nState = ControlState::NONE;
2530
2531 if ( highlight == 1 ) nState |= ControlState::PRESSED;
2532 if ( highlight == 2 ) nState |= ControlState::ROLLOVER;
2533 if ( bEnabled ) nState |= ControlState::ENABLED;
2534
2535 aControlValue.setTristateVal( bChecked ? ButtonValue::On : ButtonValue::Off );
2536
2537 bNativeOk = rRenderContext.DrawNativeControl( ControlType::Toolbar, ControlPart::Button,
2538 rRect, nState, aControlValue, OUString() );
2539 }
2540
2541 if (!bNativeOk)
2542 vcl::RenderTools::DrawSelectionBackground(rRenderContext, *this, rRect, bIsWindow ? 3 : highlight,
2543 bChecked, true, bIsWindow, nullptr, 2);
2544 }
2545
2546 void ToolBox::ImplDrawItem(vcl::RenderContext& rRenderContext, ImplToolItems::size_type nPos, sal_uInt16 nHighlight)
2547 {
2548 if (nPos >= mpData->m_aItems.size())
2549 return;
2550
2551 // execute pending paint requests
2552 ImplCheckUpdate();
2553
2554 rRenderContext.SetFillColor();
2555
2556 ImplToolItem* pItem = &mpData->m_aItems[nPos];
2557
2558 if (!pItem->mbEnabled)
2559 nHighlight = 0;
2560
2561 // if the rectangle is outside visible area
2562 if (pItem->maRect.IsEmpty())
2563 return;
2564
2565 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
2566
2567 // no gradient background for items that have a popup open
2568 bool bHasOpenPopup = mpFloatWin && (mnDownItemId==pItem->mnId);
2569
2570 bool bHighContrastWhite = false;
2571 // check the face color as highcontrast indicator
2572 // because the toolbox itself might have a gradient
2573 if (rStyleSettings.GetFaceColor() == COL_WHITE)
2574 bHighContrastWhite = true;
2575
2576 // Compute buttons area.
2577 Size aBtnSize = pItem->maRect.GetSize();
2578
2579 /* Compute the button/separator rectangle here, we'll need it for
2580 * both the buttons and the separators. */
2581 tools::Rectangle aButtonRect( pItem->maRect.TopLeft(), aBtnSize );
2582 tools::Long nOffX = SMALLBUTTON_OFF_NORMAL_X;
2583 tools::Long nOffY = SMALLBUTTON_OFF_NORMAL_Y;
2584 tools::Long nImageOffX = 0;
2585 tools::Long nImageOffY = 0;
2586 DrawButtonFlags nStyle = DrawButtonFlags::NONE;
2587
2588 // draw separators
2589 if ( (pItem->meType == ToolBoxItemType::SEPARATOR) && nPos > 0 )
2590 {
2591 ImplDrawSeparator(rRenderContext, nPos, aButtonRect);
2592 }
2593
2594 // do nothing if item is no button or will be displayed as window
2595 if ( (pItem->meType != ToolBoxItemType::BUTTON) || pItem->mbShowWindow )
2596 return;
2597
2598 if ( pItem->meState == TRISTATE_TRUE )
2599 {
2600 nStyle |= DrawButtonFlags::Checked;
2601 }
2602 else if ( pItem->meState == TRISTATE_INDET )
2603 {
2604 nStyle |= DrawButtonFlags::DontKnow;
2605 }
2606 if ( nHighlight == 1 )
2607 {
2608 nStyle |= DrawButtonFlags::Pressed;
2609 }
2610
2611 ImplErase(rRenderContext, pItem->maRect, nHighlight != 0, bHasOpenPopup );
2612
2613 nOffX += pItem->maRect.Left();
2614 nOffY += pItem->maRect.Top();
2615
2616 // determine what has to be drawn on the button: image, text or both
2617 bool bImage;
2618 bool bText;
2619 ButtonType tmpButtonType = determineButtonType( pItem, meButtonType ); // default to toolbox setting
2620 pItem->DetermineButtonDrawStyle( tmpButtonType, bImage, bText );
2621
2622 // compute output values
2623 tools::Long nBtnWidth = aBtnSize.Width()-SMALLBUTTON_HSIZE;
2624 tools::Long nBtnHeight = aBtnSize.Height()-SMALLBUTTON_VSIZE;
2625 Size aImageSize;
2626
2627 const bool bDropDown = (pItem->mnBits & ToolBoxItemBits::DROPDOWN) == ToolBoxItemBits::DROPDOWN;
2628 tools::Rectangle aDropDownRect;
2629 if (bDropDown)
2630 aDropDownRect = pItem->GetDropDownRect(mbHorz);
2631
2632 if ( bImage )
2633 {
2634 const Image* pImage = &(pItem->maImage);
2635 aImageSize = pImage->GetSizePixel();
2636
2637 // determine drawing flags
2638 DrawImageFlags nImageStyle = DrawImageFlags::NONE;
2639
2640 if ( !pItem->mbEnabled || !IsEnabled() )
2641 nImageStyle |= DrawImageFlags::Disable;
2642
2643 // #i35563# the dontknow state indicates different states at the same time
2644 // which should not be rendered disabled but normal
2645
2646 // draw the image
2647 nImageOffX = nOffX;
2648 nImageOffY = nOffY;
2649 if ( ( (pItem->mnBits & (ToolBoxItemBits::LEFT|ToolBoxItemBits::DROPDOWN)) || bText )
2650 && ( meTextPosition == ToolBoxTextPosition::Right ) )
2651 {
2652 // left align also to leave space for drop down arrow
2653 // and when drawing text+image
2654 // just center in y, except for vertical (ie rotated text)
2655 if( mbHorz || !bText )
2656 nImageOffY += (nBtnHeight-aImageSize.Height())/2;
2657 }
2658 else
2659 {
2660 nImageOffX += (nBtnWidth-(bDropDown ? aDropDownRect.getOpenWidth() : 0)+SMALLBUTTON_OFF_NORMAL_X-aImageSize.Width())/2;
2661 if ( meTextPosition == ToolBoxTextPosition::Right )
2662 nImageOffY += (nBtnHeight-aImageSize.Height())/2;
2663 }
2664 if ( nHighlight != 0 || (pItem->meState == TRISTATE_TRUE) )
2665 {
2666 if( bHasOpenPopup )
2667 ImplDrawFloatwinBorder(rRenderContext, pItem);
2668 else
2669 ImplDrawButton(rRenderContext, aButtonRect, nHighlight, pItem->meState == TRISTATE_TRUE,
2670 pItem->mbEnabled && IsEnabled(), pItem->mbShowWindow);
2671
2672 if( nHighlight != 0 )
2673 {
2674 if( bHighContrastWhite )
2675 nImageStyle |= DrawImageFlags::ColorTransform;
2676 }
2677 }
2678 rRenderContext.DrawImage(Point( nImageOffX, nImageOffY ), *pImage, nImageStyle);
2679 }
2680
2681 // draw the text
2682 bool bRotate = false;
2683 if ( bText )
2684 {
2685 const Size aTxtSize(GetOutDev()->GetCtrlTextWidth(pItem->maText), GetTextHeight());
2686 tools::Long nTextOffX = nOffX;
2687 tools::Long nTextOffY = nOffY;
2688
2689 // rotate text when vertically docked
2690 vcl::Font aOldFont = rRenderContext.GetFont();
2691 if( pItem->mbVisibleText && !ImplIsFloatingMode() &&
2692 ((meAlign == WindowAlign::Left) || (meAlign == WindowAlign::Right)) )
2693 {
2694 bRotate = true;
2695
2696 vcl::Font aRotateFont = aOldFont;
2697 aRotateFont.SetOrientation( 2700_deg10 );
2698
2699 // center horizontally
2700 nTextOffX += aTxtSize.Height();
2701 nTextOffX += (nBtnWidth-aTxtSize.Height())/2;
2702
2703 // add in image offset
2704 if( bImage )
2705 nTextOffY = nImageOffY + aImageSize.Height() + TB_IMAGETEXTOFFSET;
2706
2707 rRenderContext.SetFont(aRotateFont);
2708 }
2709 else
2710 {
2711 if ( meTextPosition == ToolBoxTextPosition::Right )
2712 {
2713 // center vertically
2714 nTextOffY += (nBtnHeight-aTxtSize.Height())/2;
2715
2716 // add in image offset
2717 if( bImage )
2718 nTextOffX = nImageOffX + aImageSize.Width() + TB_IMAGETEXTOFFSET;
2719 }
2720 else
2721 {
2722 // center horizontally
2723 nTextOffX += (nBtnWidth-(bDropDown ? aDropDownRect.getOpenWidth() : 0)+SMALLBUTTON_OFF_NORMAL_X-aTxtSize.Width() - TB_IMAGETEXTOFFSET)/2;
2724 // set vertical position
2725 nTextOffY += nBtnHeight - aTxtSize.Height();
2726 }
2727 }
2728
2729 // draw selection only if not already drawn during image output (see above)
2730 if ( !bImage && (nHighlight != 0 || (pItem->meState == TRISTATE_TRUE) ) )
2731 {
2732 if( bHasOpenPopup )
2733 ImplDrawFloatwinBorder(rRenderContext, pItem);
2734 else
2735 ImplDrawButton(rRenderContext, pItem->maRect, nHighlight, pItem->meState == TRISTATE_TRUE,
2736 pItem->mbEnabled && IsEnabled(), pItem->mbShowWindow );
2737 }
2738
2739 DrawTextFlags nTextStyle = DrawTextFlags::NONE;
2740 if ( !pItem->mbEnabled )
2741 nTextStyle |= DrawTextFlags::Disable;
2742 rRenderContext.DrawCtrlText( Point( nTextOffX, nTextOffY ), pItem->maText,
2743 0, pItem->maText.getLength(), nTextStyle );
2744 if ( bRotate )
2745 SetFont( aOldFont );
2746 }
2747
2748 // paint optional drop down arrow
2749 if (!bDropDown)
2750 return;
2751
2752 bool bSetColor = true;
2753 if ( !pItem->mbEnabled || !IsEnabled() )
2754 {
2755 bSetColor = false;
2756 rRenderContext.SetFillColor(rStyleSettings.GetShadowColor());
2757 }
2758
2759 // dropdown only will be painted without inner border
2760 if( (pItem->mnBits & ToolBoxItemBits::DROPDOWNONLY) != ToolBoxItemBits::DROPDOWNONLY )
2761 {
2762 ImplErase(rRenderContext, aDropDownRect, nHighlight != 0, bHasOpenPopup);
2763
2764 if( nHighlight != 0 || (pItem->meState == TRISTATE_TRUE) )
2765 {
2766 if( bHasOpenPopup )
2767 ImplDrawFloatwinBorder(rRenderContext, pItem);
2768 else
2769 ImplDrawButton(rRenderContext, aDropDownRect, nHighlight, pItem->meState == TRISTATE_TRUE,
2770 pItem->mbEnabled && IsEnabled(), false);
2771 }
2772 }
2773 ImplDrawDropdownArrow(rRenderContext, aDropDownRect, bSetColor, bRotate);
2774 }
2775
2776 void ToolBox::ImplDrawFloatwinBorder(vcl::RenderContext& rRenderContext, ImplToolItem const * pItem)
2777 {
2778 if ( pItem->maRect.IsEmpty() )
2779 return;
2780
2781 rRenderContext.SetLineColor(rRenderContext.GetSettings().GetStyleSettings().GetShadowColor());
2782 Point p1, p2;
2783
2784 p1 = pItem->maRect.TopLeft();
2785 p1.AdjustX( 1 );
2786 p2 = pItem->maRect.TopRight();
2787 p2.AdjustX( -1 );
2788 rRenderContext.DrawLine( p1, p2);
2789 p1 = pItem->maRect.BottomLeft();
2790 p1.AdjustX( 1 );
2791 p2 = pItem->maRect.BottomRight();
2792 p2.AdjustX( -1 );
2793 rRenderContext.DrawLine( p1, p2);
2794
2795 p1 = pItem->maRect.TopLeft();
2796 p1.AdjustY( 1 );
2797 p2 = pItem->maRect.BottomLeft();
2798 p2.AdjustY( -1 );
2799 rRenderContext.DrawLine( p1, p2);
2800 p1 = pItem->maRect.TopRight();
2801 p1.AdjustY( 1 );
2802 p2 = pItem->maRect.BottomRight();
2803 p2.AdjustY( -1 );
2804 rRenderContext.DrawLine( p1, p2);
2805
2806 }
2807
2808 void ToolBox::ImplFloatControl( bool bStart, FloatingWindow* pFloatWindow )
2809 {
2810
2811 if ( bStart )
2812 {
2813 mpFloatWin = pFloatWindow;
2814
2815 // redraw item, to trigger drawing of a special border
2816 InvalidateItem(mnCurPos);
2817
2818 mbDrag = false;
2819 EndTracking();
2820 if (IsMouseCaptured())
2821 ReleaseMouse();
2822 }
2823 else
2824 {
2825 mpFloatWin = nullptr;
2826
2827 // if focus is still in this toolbox, then the floater was opened by keyboard
2828 // draw current item with highlight and keep old state
2829 bool bWasKeyboardActivate = mpData->mbDropDownByKeyboard;
2830
2831 if ( mnCurPos != ITEM_NOTFOUND )
2832 InvalidateItem(mnCurPos);
2833 Deactivate();
2834
2835 if( !bWasKeyboardActivate )
2836 {
2837 mnCurPos = ITEM_NOTFOUND;
2838 mnCurItemId = ToolBoxItemId(0);
2839 mnHighItemId = ToolBoxItemId(0);
2840 }
2841 mnDownItemId = ToolBoxItemId(0);
2842
2843 }
2844 }
2845
2846 void ToolBox::ShowLine( bool bNext )
2847 {
2848 mbFormat = true;
2849
2850 if ( bNext )
2851 mnCurLine++;
2852 else
2853 mnCurLine--;
2854
2855 ImplFormat();
2856 }
2857
2858 bool ToolBox::ImplHandleMouseMove( const MouseEvent& rMEvt, bool bRepeat )
2859 {
2860 Point aMousePos = rMEvt.GetPosPixel();
2861
2862 if ( !mpData )
2863 return false;
2864
2865 // ToolBox active?
2866 if ( mbDrag && mnCurPos != ITEM_NOTFOUND )
2867 {
2868 // is the cursor over the item?
2869 ImplToolItem* pItem = &mpData->m_aItems[mnCurPos];
2870 if ( pItem->maRect.Contains( aMousePos ) )
2871 {
2872 if ( !mnCurItemId )
2873 {
2874 InvalidateItem(mnCurPos);
2875 mnCurItemId = pItem->mnId;
2876 Highlight();
2877 }
2878
2879 if ( (pItem->mnBits & ToolBoxItemBits::REPEAT) && bRepeat )
2880 Select();
2881 }
2882 else
2883 {
2884 if ( mnCurItemId )
2885 {
2886 InvalidateItem(mnCurPos);
2887 mnCurItemId = ToolBoxItemId(0);
2888 InvalidateItem(mnCurPos);
2889 Highlight();
2890 }
2891 }
2892
2893 return true;
2894 }
2895
2896 if ( mbUpper )
2897 {
2898 bool bNewIn = maUpperRect.Contains( aMousePos );
2899 if ( bNewIn != mbIn )
2900 {
2901 mbIn = bNewIn;
2902 InvalidateSpin(true, false);
2903 }
2904 return true;
2905 }
2906
2907 if ( mbLower )
2908 {
2909 bool bNewIn = maLowerRect.Contains( aMousePos );
2910 if ( bNewIn != mbIn )
2911 {
2912 mbIn = bNewIn;
2913 InvalidateSpin(false);
2914 }
2915 return true;
2916 }
2917
2918 return false;
2919 }
2920
2921 bool ToolBox::ImplHandleMouseButtonUp( const MouseEvent& rMEvt, bool bCancel )
2922 {
2923 if ( !mpData )
2924 return false;
2925
2926 // stop eventual running dropdown timer
2927 if( mnCurPos < mpData->m_aItems.size() &&
2928 (mpData->m_aItems[mnCurPos].mnBits & ToolBoxItemBits::DROPDOWN ) )
2929 {
2930 mpData->maDropdownTimer.Stop();
2931 }
2932
2933 if ( mbDrag )
2934 {
2935 Deactivate();
2936
2937 if ( mbDrag )
2938 mbDrag = false;
2939 else
2940 {
2941 if ( mnCurPos == ITEM_NOTFOUND )
2942 return true;
2943 }
2944
2945 // has mouse been released on top of item?
2946 if( mnCurPos < mpData->m_aItems.size() )
2947 {
2948 ImplToolItem* pItem = &mpData->m_aItems[mnCurPos];
2949 if ( pItem->maRect.Contains( rMEvt.GetPosPixel() ) )
2950 {
2951 mnCurItemId = pItem->mnId;
2952 if ( !bCancel )
2953 {
2954 // execute AutoCheck if required
2955 if ( pItem->mnBits & ToolBoxItemBits::AUTOCHECK )
2956 {
2957 if ( pItem->mnBits & ToolBoxItemBits::RADIOCHECK )
2958 {
2959 if ( pItem->meState != TRISTATE_TRUE )
2960 SetItemState( pItem->mnId, TRISTATE_TRUE );
2961 }
2962 else
2963 {
2964 if ( pItem->meState != TRISTATE_TRUE )
2965 pItem->meState = TRISTATE_TRUE;
2966 else
2967 pItem->meState = TRISTATE_FALSE;
2968 }
2969 }
2970
2971 // do not call Select when Repeat is active, as in this
2972 // case that was triggered already in MouseButtonDown
2973 if ( !(pItem->mnBits & ToolBoxItemBits::REPEAT) )
2974 {
2975 // prevent from being destroyed in the select handler
2976 VclPtr<vcl::Window> xWindow = this;
2977 Select();
2978 if ( xWindow->isDisposed() )
2979 return true;
2980 }
2981 }
2982
2983 {
2984 }
2985
2986 // Items not destroyed, in Select handler
2987 if ( mnCurItemId )
2988 {
2989 // Get current pos for the case that items are inserted/removed
2990 // in the toolBox
2991 mnCurPos = GetItemPos( mnCurItemId );
2992 if ( mnCurPos != ITEM_NOTFOUND )
2993 {
2994 InvalidateItem(mnCurPos);
2995 GetOutDev()->Flush();
2996 }
2997 }
2998 }
2999 }
3000
3001 mnCurPos = ITEM_NOTFOUND;
3002 mnCurItemId = ToolBoxItemId(0);
3003 mnDownItemId = ToolBoxItemId(0);
3004 mnMouseModifier = 0;
3005 return true;
3006 }
3007 else if ( mbUpper || mbLower )
3008 {
3009 if ( mbIn )
3010 ShowLine( !mbUpper );
3011 mbUpper = false;
3012 mbLower = false;
3013 mbIn = false;
3014 InvalidateSpin();
3015 return true;
3016 }
3017
3018 return false;
3019 }
3020
3021 void ToolBox::MouseMove( const MouseEvent& rMEvt )
3022 {
3023 // pressing a modifier generates synthetic mouse moves
3024 // ignore it if keyboard selection is active
3025 if( HasFocus() && ( rMEvt.GetMode() & MouseEventModifiers::MODIFIERCHANGED ) )
3026 return;
3027
3028 if ( ImplHandleMouseMove( rMEvt ) )
3029 return;
3030
3031 Point aMousePos = rMEvt.GetPosPixel();
3032
3033 // only highlight when the focus is not inside a child window of a toolbox
3034 // eg, in an edit control
3035 // and do not highlight when focus is in a different toolbox
3036 bool bDrawHotSpot = true;
3037 vcl::Window *pFocusWin = Application::GetFocusWindow();
3038
3039 bool bFocusWindowIsAToolBoxChild = false;
3040 if (pFocusWin)
3041 {
3042 vcl::Window *pWin = pFocusWin->GetParent();
3043 while (pWin)
3044 {
3045 if(pWin->ImplGetWindowImpl() && pWin->ImplGetWindowImpl()->mbToolBox)
3046 {
3047 bFocusWindowIsAToolBoxChild = true;
3048 break;
3049 }
3050 pWin = pWin->GetParent();
3051 }
3052 }
3053
3054 if( bFocusWindowIsAToolBoxChild || (pFocusWin && pFocusWin->ImplGetWindowImpl() && pFocusWin->ImplGetWindowImpl()->mbToolBox && pFocusWin != this) )
3055 bDrawHotSpot = false;
3056
3057 if ( mbDragging )
3058 {
3059 ImplTBDragMgr* pMgr = ImplGetTBDragMgr();
3060 pMgr->Dragging( aMousePos );
3061 return;
3062 }
3063
3064 PointerStyle eStyle = PointerStyle::Arrow;
3065
3066 // change mouse cursor over drag area
3067 ImplDockingWindowWrapper *pWrapper = ImplGetDockingManager()->GetDockingWindowWrapper( this );
3068 if( pWrapper && pWrapper->GetDragArea().Contains( rMEvt.GetPosPixel() ) )
3069 eStyle = PointerStyle::Move;
3070
3071 if ( (mnWinStyle & TB_WBLINESIZING) == TB_WBLINESIZING )
3072 {
3073 if ( rMEvt.GetMode() & MouseEventModifiers::SIMPLEMOVE )
3074 {
3075 sal_uInt16 nLinePtr = ImplTestLineSize( rMEvt.GetPosPixel() );
3076 if ( nLinePtr & DOCK_LINEHSIZE )
3077 {
3078 if ( meAlign == WindowAlign::Left )
3079 eStyle = PointerStyle::WindowESize;
3080 else
3081 eStyle = PointerStyle::WindowWSize;
3082 }
3083 else if ( nLinePtr & DOCK_LINEVSIZE )
3084 {
3085 if ( meAlign == WindowAlign::Top )
3086 eStyle = PointerStyle::WindowSSize;
3087 else
3088 eStyle = PointerStyle::WindowNSize;
3089 }
3090 }
3091 }
3092
3093 if ( bDrawHotSpot )
3094 {
3095 bool bClearHigh = true;
3096 if ( !rMEvt.IsLeaveWindow() && (mnCurPos == ITEM_NOTFOUND) )
3097 {
3098 ImplToolItems::size_type nTempPos = 0;
3099 for (auto const& item : mpData->m_aItems)
3100 {
3101 if ( item.maRect.Contains( aMousePos ) )
3102 {
3103 if ( (item.meType == ToolBoxItemType::BUTTON) && item.mbEnabled )
3104 {
3105 bClearHigh = false;
3106 if ( mnHighItemId != item.mnId )
3107 {
3108 if ( mnHighItemId )
3109 {
3110 ImplHideFocus();
3111 ImplToolItems::size_type nPos = GetItemPos( mnHighItemId );
3112 InvalidateItem(nPos);
3113 CallEventListeners( VclEventId::ToolboxHighlightOff, reinterpret_cast< void* >( nPos ) );
3114 }
3115 if ( mpData->mbMenubuttonSelected )
3116 {
3117 // remove highlight from menubutton
3118 InvalidateMenuButton();
3119 }
3120 mnHighItemId = item.mnId;
3121 InvalidateItem(nTempPos);
3122 ImplShowFocus();
3123 CallEventListeners( VclEventId::ToolboxHighlight );
3124 }
3125 }
3126 break;
3127 }
3128 ++nTempPos;
3129 }
3130 }
3131
3132 // only clear highlight when focus is not in toolbar
3133 bool bMenuButtonHit = mpData->maMenubuttonItem.maRect.Contains( aMousePos ) && ImplHasClippedItems();
3134 if ( !HasFocus() && (bClearHigh || bMenuButtonHit) )
3135 {
3136 if ( !bMenuButtonHit && mpData->mbMenubuttonSelected )
3137 {
3138 // remove highlight from menubutton
3139 InvalidateMenuButton();
3140 }
3141
3142 if( mnHighItemId )
3143 {
3144 ImplToolItems::size_type nClearPos = GetItemPos( mnHighItemId );
3145 if ( nClearPos != ITEM_NOTFOUND )
3146 {
3147 InvalidateItem(nClearPos);
3148 if( nClearPos != mnCurPos )
3149 CallEventListeners( VclEventId::ToolboxHighlightOff, reinterpret_cast< void* >( nClearPos ) );
3150 }
3151 ImplHideFocus();
3152 mnHighItemId = ToolBoxItemId(0);
3153 }
3154
3155 if( bMenuButtonHit )
3156 {
3157 InvalidateMenuButton();
3158 }
3159 }
3160 }
3161
3162 if ( meLastStyle != eStyle )
3163 {
3164 meLastStyle = eStyle;
3165 SetPointer( eStyle );
3166 }
3167
3168 DockingWindow::MouseMove( rMEvt );
3169 }
3170
3171 void ToolBox::MouseButtonDown( const MouseEvent& rMEvt )
3172 {
3173 // only trigger toolbox for left mouse button and when
3174 // we're not in normal operation
3175 if ( rMEvt.IsLeft() && !mbDrag && (mnCurPos == ITEM_NOTFOUND) )
3176 {
3177 // call activate already here, as items could
3178 // be exchanged
3179 Activate();
3180
3181 // update ToolBox here, such that user knows it
3182 if ( mbFormat )
3183 {
3184 ImplFormat();
3185 PaintImmediately();
3186 }
3187
3188 Point aMousePos = rMEvt.GetPosPixel();
3189 ImplToolItems::size_type i = 0;
3190 ImplToolItems::size_type nNewPos = ITEM_NOTFOUND;
3191
3192 // search for item that was clicked
3193 for (auto const& item : mpData->m_aItems)
3194 {
3195 // is this the item?
3196 if ( item.maRect.Contains( aMousePos ) )
3197 {
3198 // do nothing if it is a separator or
3199 // if the item has been disabled
3200 if ( (item.meType == ToolBoxItemType::BUTTON) &&
3201 !item.mbShowWindow )
3202 nNewPos = i;
3203
3204 break;
3205 }
3206
3207 i++;
3208 }
3209
3210 // item found
3211 if ( nNewPos != ITEM_NOTFOUND )
3212 {
3213 if ( !mpData->m_aItems[nNewPos].mbEnabled )
3214 {
3215 Deactivate();
3216 return;
3217 }
3218
3219 // update actual data
3220 StartTrackingFlags nTrackFlags = StartTrackingFlags::NONE;
3221 mnCurPos = nNewPos;
3222 mnCurItemId = mpData->m_aItems[nNewPos].mnId;
3223 mnDownItemId = mnCurItemId;
3224 mnMouseModifier = rMEvt.GetModifier();
3225 if ( mpData->m_aItems[nNewPos].mnBits & ToolBoxItemBits::REPEAT )
3226 nTrackFlags |= StartTrackingFlags::ButtonRepeat;
3227
3228 // update bDrag here, as it is evaluated in the EndSelection
3229 mbDrag = true;
3230
3231 // on double-click: only call the handler, but do so before the button
3232 // is hit, as in the handler dragging
3233 // can be terminated
3234 if ( rMEvt.GetClicks() == 2 )
3235 DoubleClick();
3236
3237 if ( mbDrag )
3238 {
3239 InvalidateItem(mnCurPos);
3240 Highlight();
3241 }
3242
3243 // was dropdown arrow pressed
3244 if( mpData->m_aItems[nNewPos].mnBits & ToolBoxItemBits::DROPDOWN )
3245 {
3246 if( ( (mpData->m_aItems[nNewPos].mnBits & ToolBoxItemBits::DROPDOWNONLY) == ToolBoxItemBits::DROPDOWNONLY)
3247 || mpData->m_aItems[nNewPos].GetDropDownRect( mbHorz ).Contains( aMousePos ))
3248 {
3249 // dropdownonly always triggers the dropdown handler, over the whole button area
3250
3251 // the drop down arrow should not trigger the item action
3252 mpData->mbDropDownByKeyboard = false;
3253 mpData->maDropdownClickHdl.Call( this );
3254
3255 // do not reset data if the dropdown handler opened a floating window
3256 // see ImplFloatControl()
3257 if( !mpFloatWin )
3258 {
3259 // no floater was opened
3260 Deactivate();
3261 InvalidateItem(mnCurPos);
3262
3263 mnCurPos = ITEM_NOTFOUND;
3264 mnCurItemId = ToolBoxItemId(0);
3265 mnDownItemId = ToolBoxItemId(0);
3266 mnMouseModifier = 0;
3267 mnHighItemId = ToolBoxItemId(0);
3268 }
3269 return;
3270 }
3271 else // activate long click timer
3272 mpData->maDropdownTimer.Start();
3273 }
3274
3275 // call Click handler
3276 if ( rMEvt.GetClicks() != 2 )
3277 Click();
3278
3279 // also call Select handler at repeat
3280 if ( nTrackFlags & StartTrackingFlags::ButtonRepeat )
3281 Select();
3282
3283 // if the actions was not aborted in Click handler
3284 if ( mbDrag )
3285 StartTracking( nTrackFlags );
3286
3287 // if mouse was clicked over an item we
3288 // can abort here
3289 return;
3290 }
3291
3292 Deactivate();
3293
3294 // menu button hit ?
3295 if( mpData->maMenubuttonItem.maRect.Contains( aMousePos ) && ImplHasClippedItems() )
3296 {
3297 if ( maMenuButtonHdl.IsSet() )
3298 maMenuButtonHdl.Call( this );
3299 else
3300 ExecuteCustomMenu( mpData->maMenubuttonItem.maRect );
3301 return;
3302 }
3303
3304 // check scroll- and next-buttons here
3305 if ( maUpperRect.Contains( aMousePos ) )
3306 {
3307 if ( mnCurLine > 1 )
3308 {
3309 StartTracking();
3310 mbUpper = true;
3311 mbIn = true;
3312 InvalidateSpin(true, false);
3313 }
3314 return;
3315 }
3316 if ( maLowerRect.Contains( aMousePos ) )
3317 {
3318 if ( mnCurLine+mnVisLines-1 < mnCurLines )
3319 {
3320 StartTracking();
3321 mbLower = true;
3322 mbIn = true;
3323 InvalidateSpin(false);
3324 }
3325 return;
3326 }
3327
3328 // Linesizing testen
3329 if ( (mnWinStyle & TB_WBLINESIZING) == TB_WBLINESIZING )
3330 {
3331 sal_uInt16 nLineMode = ImplTestLineSize( aMousePos );
3332 if ( nLineMode )
3333 {
3334 ImplTBDragMgr* pMgr = ImplGetTBDragMgr();
3335
3336 // call handler, such that we can set the
3337 // dock rectangles
3338 StartDocking();
3339
3340 Point aPos = GetParent()->OutputToScreenPixel( GetPosPixel() );
3341 Size aSize = GetSizePixel();
3342 aPos = ScreenToOutputPixel( aPos );
3343
3344 // start dragging
3345 pMgr->StartDragging( this, aMousePos, tools::Rectangle( aPos, aSize ),
3346 nLineMode );
3347 return;
3348 }
3349 }
3350
3351 // no item, then only click or double click
3352 if ( rMEvt.GetClicks() == 2 )
3353 DoubleClick();
3354 else
3355 Click();
3356 }
3357
3358 if ( !mbDrag && (mnCurPos == ITEM_NOTFOUND) )
3359 DockingWindow::MouseButtonDown( rMEvt );
3360 }
3361
3362 void ToolBox::MouseButtonUp( const MouseEvent& rMEvt )
3363 {
3364 if ( ImplHandleMouseButtonUp( rMEvt ) )
3365 return;
3366
3367 if ( mbDragging && rMEvt.IsLeft() )
3368 {
3369 ImplTBDragMgr* pMgr = ImplGetTBDragMgr();
3370 pMgr->EndDragging();
3371 return;
3372 }
3373
3374 DockingWindow::MouseButtonUp( rMEvt );
3375 }
3376
3377 void ToolBox::Tracking( const TrackingEvent& rTEvt )
3378 {
3379 VclPtr<vcl::Window> xWindow = this;
3380
3381 if ( rTEvt.IsTrackingEnded() )
3382 ImplHandleMouseButtonUp( rTEvt.GetMouseEvent(), rTEvt.IsTrackingCanceled() );
3383 else
3384 ImplHandleMouseMove( rTEvt.GetMouseEvent(), rTEvt.IsTrackingRepeat() );
3385
3386 if ( xWindow->isDisposed() )
3387 // toolbox was deleted
3388 return;
3389 DockingWindow::Tracking( rTEvt );
3390 }
3391
3392 void ToolBox::InvalidateItem(ImplToolItems::size_type nPosition)
3393 {
3394 if (mpData && nPosition < mpData->m_aItems.size())
3395 {
3396 ImplToolItem* pItem = &mpData->m_aItems[nPosition];
3397 Invalidate(pItem->maRect);
3398 }
3399 }
3400
3401 void ToolBox::InvalidateMenuButton()
3402 {
3403 if (!mpData->maMenubuttonItem.maRect.IsEmpty())
3404 Invalidate(mpData->maMenubuttonItem.maRect);
3405 }
3406
3407 void ToolBox::InvalidateSpin(bool bUpperIn, bool bLowerIn)
3408 {
3409 if (bUpperIn && !maUpperRect.IsEmpty())
3410 Invalidate(maUpperRect);
3411
3412 if (bLowerIn && !maLowerRect.IsEmpty())
3413 Invalidate(maLowerRect);
3414 }
3415
3416 void ToolBox::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rPaintRect)
3417 {
3418 if( mpData->mbIsPaintLocked )
3419 return;
3420
3421 if (rPaintRect == tools::Rectangle(0, 0, mnDX-1, mnDY-1))
3422 mbFullPaint = true;
3423 ImplFormat();
3424 mbFullPaint = false;
3425
3426 ImplDrawBackground(rRenderContext, rPaintRect);
3427
3428 if ( (mnWinStyle & WB_BORDER) && !ImplIsFloatingMode() )
3429 ImplDrawBorder(rRenderContext);
3430
3431 if( !ImplIsFloatingMode() )
3432 ImplDrawGrip(rRenderContext);
3433
3434 ImplDrawMenuButton(rRenderContext, mpData->mbMenubuttonSelected);
3435
3436 // draw SpinButtons
3437 if (mnWinStyle & WB_SCROLL)
3438 {
3439 if (mnCurLines > mnLines)
3440 ImplDrawSpin(rRenderContext);
3441 }
3442
3443 // draw buttons
3444 ImplToolItems::size_type nHighPos;
3445 if ( mnHighItemId )
3446 nHighPos = GetItemPos( mnHighItemId );
3447 else
3448 nHighPos = ITEM_NOTFOUND;
3449
3450 ImplToolItems::size_type nCount = mpData->m_aItems.size();
3451 for( ImplToolItems::size_type i = 0; i < nCount; i++ )
3452 {
3453 ImplToolItem* pItem = &mpData->m_aItems[i];
3454
3455 // only draw when the rectangle is in the draw rectangle
3456 if ( !pItem->maRect.IsEmpty() && rPaintRect.Overlaps( pItem->maRect ) )
3457 {
3458 sal_uInt16 nHighlight = 0;
3459 if ( i == mnCurPos )
3460 nHighlight = 1;
3461 else if ( i == nHighPos )
3462 nHighlight = 2;
3463 ImplDrawItem(rRenderContext, i, nHighlight);
3464 }
3465 }
3466 ImplShowFocus();
3467 }
3468
3469 void ToolBox::Resize()
3470 {
3471 Size aSize = GetOutputSizePixel();
3472 // #i31422# some WindowManagers send (0,0) sizes when
3473 // switching virtual desktops - ignore this and avoid reformatting
3474 if( !aSize.Width() && !aSize.Height() )
3475 return;
3476
3477 tools::Long nOldDX = mnDX;
3478 tools::Long nOldDY = mnDY;
3479 mnDX = aSize.Width();
3480 mnDY = aSize.Height();
3481
3482 mnLastResizeDY = 0;
3483
3484 // invalidate everything to have gradient backgrounds properly drawn
3485 Invalidate();
3486
3487 // If we have any expandable entries, then force a reformat first using
3488 // their optimal sizes, then share out the excess space evenly across those
3489 // expandables and reformat again
3490 std::vector<size_t> aExpandables;
3491 for (size_t i = 0; i < mpData->m_aItems.size(); ++i)
3492 {
3493 if (mpData->m_aItems[i].mbExpand)
3494 {
3495 vcl::Window *pWindow = mpData->m_aItems[i].mpWindow;
3496 SAL_INFO_IF(!pWindow, "vcl.layout", "only tabitems with window supported at the moment");
3497 if (!pWindow)
3498 continue;
3499 Size aWinSize(pWindow->GetSizePixel());
3500 Size aPrefSize(pWindow->get_preferred_size());
3501 aWinSize.setWidth( aPrefSize.Width() );
3502 pWindow->SetSizePixel(aWinSize);
3503 aExpandables.push_back(i);
3504 }
3505 }
3506
3507 // re-format or re-draw
3508 if ( mbScroll || !aExpandables.empty() )
3509 {
3510 if ( !mbFormat || !aExpandables.empty() )
3511 {
3512 mbFormat = true;
3513 if( IsReallyVisible() || !aExpandables.empty() )
3514 {
3515 ImplFormat(true);
3516
3517 if (!aExpandables.empty())
3518 {
3519 //Get how big the optimal size is
3520 tools::Rectangle aBounds;
3521 for (const ImplToolItem & rItem : mpData->m_aItems)
3522 {
3523 aBounds.Union( rItem.maRect );
3524 }
3525
3526 auto nOptimalWidth = aBounds.GetWidth();
3527 auto nDiff = aSize.Width() - nOptimalWidth;
3528 decltype(nDiff) nExpandablesSize = aExpandables.size();
3529 nDiff /= nExpandablesSize;
3530
3531 //share out the diff from optimal to real across
3532 //expandable entries
3533 for (size_t nIndex : aExpandables)
3534 {
3535 vcl::Window *pWindow = mpData->m_aItems[nIndex].mpWindow;
3536 Size aWinSize(pWindow->GetSizePixel());
3537 Size aPrefSize(pWindow->get_preferred_size());
3538 aWinSize.setWidth( aPrefSize.Width() + nDiff );
3539 pWindow->SetSizePixel(aWinSize);
3540 }
3541
3542 //now reformat with final sizes
3543 mbFormat = true;
3544 ImplFormat(true);
3545 }
3546 }
3547 }
3548 }
3549
3550 // redraw border
3551 if ( !(mnWinStyle & WB_BORDER) )
3552 return;
3553
3554 // as otherwise, when painting we might think we have to re-draw everything
3555 if ( mbFormat && IsReallyVisible() )
3556 Invalidate();
3557 else
3558 {
3559 if ( mnRightBorder )
3560 {
3561 if ( nOldDX > mnDX )
3562 Invalidate( tools::Rectangle( mnDX-mnRightBorder-1, 0, mnDX, mnDY ) );
3563 else
3564 Invalidate( tools::Rectangle( nOldDX-mnRightBorder-1, 0, nOldDX, nOldDY ) );
3565 }
3566
3567 if ( mnBottomBorder )
3568 {
3569 if ( nOldDY > mnDY )
3570 Invalidate( tools::Rectangle( 0, mnDY-mnBottomBorder-1, mnDX, mnDY ) );
3571 else
3572 Invalidate( tools::Rectangle( 0, nOldDY-mnBottomBorder-1, nOldDX, nOldDY ) );
3573 }
3574 }
3575 }
3576
3577 namespace
3578 {
3579 bool DispatchableCommand(std::u16string_view rName)
3580 {
3581 return o3tl::starts_with(rName, u".uno") ||
3582 o3tl::starts_with(rName, u"slot:") ||
3583 o3tl::starts_with(rName, u"macro:") ||
3584 o3tl::starts_with(rName, u"vnd.sun.star.script");
3585 }
3586 }
3587
3588 const OUString& ToolBox::ImplGetHelpText( ToolBoxItemId nItemId ) const
3589 {
3590 ImplToolItem* pItem = ImplGetItem( nItemId );
3591
3592 assert( pItem );
3593
3594 if ( pItem->maHelpText.isEmpty() && ( !pItem->maHelpId.isEmpty() || pItem->maCommandStr.getLength() ))
3595 {
3596 Help* pHelp = Application::GetHelp();
3597 if ( pHelp )
3598 {
3599 if (DispatchableCommand(pItem->maCommandStr))
3600 pItem->maHelpText = pHelp->GetHelpText( pItem->maCommandStr );
3601 if ( pItem->maHelpText.isEmpty() && !pItem->maHelpId.isEmpty() )
3602 pItem->maHelpText = pHelp->GetHelpText( pItem->maHelpId );
3603 }
3604 }
3605
3606 return pItem->maHelpText;
3607 }
3608
3609 void ToolBox::RequestHelp( const HelpEvent& rHEvt )
3610 {
3611 ToolBoxItemId nItemId;
3612 Point aHelpPos;
3613
3614 if( !rHEvt.KeyboardActivated() )
3615 {
3616 nItemId = GetItemId( ScreenToOutputPixel( rHEvt.GetMousePosPixel() ) );
3617 aHelpPos = rHEvt.GetMousePosPixel();
3618 }
3619 else
3620 {
3621 if( !mnHighItemId )
3622 return;
3623 else
3624 nItemId = mnHighItemId;
3625 tools::Rectangle aRect( GetItemRect( nItemId ) );
3626 if( aRect.IsEmpty() )
3627 return;
3628 else
3629 aHelpPos = OutputToScreenPixel( aRect.Center() );
3630 }
3631
3632 if ( nItemId )
3633 {
3634 if ( rHEvt.GetMode() & (HelpEventMode::BALLOON | HelpEventMode::QUICK) )
3635 {
3636 // get rectangle
3637 tools::Rectangle aTempRect = GetItemRect( nItemId );
3638 Point aPt = OutputToScreenPixel( aTempRect.TopLeft() );
3639 aTempRect.SetLeft( aPt.X() );
3640 aTempRect.SetTop( aPt.Y() );
3641 aPt = OutputToScreenPixel( aTempRect.BottomRight() );
3642 aTempRect.SetRight( aPt.X() );
3643 aTempRect.SetBottom( aPt.Y() );
3644
3645 // get text and display it
3646 OUString aStr = GetQuickHelpText( nItemId );
3647 if (aStr.isEmpty())
3648 aStr = MnemonicGenerator::EraseAllMnemonicChars( GetItemText( nItemId ) );
3649 if ( rHEvt.GetMode() & HelpEventMode::BALLOON )
3650 {
3651 const OUString& rHelpStr = GetHelpText( nItemId );
3652 if (!rHelpStr.isEmpty())
3653 aStr = rHelpStr;
3654 Help::ShowBalloon( this, aHelpPos, aTempRect, aStr );
3655 }
3656 else
3657 Help::ShowQuickHelp( this, aTempRect, aStr, QuickHelpFlags::CtrlText );
3658 return;
3659 }
3660 }
3661
3662 DockingWindow::RequestHelp( rHEvt );
3663 }
3664
3665 bool ToolBox::EventNotify( NotifyEvent& rNEvt )
3666 {
3667 if ( rNEvt.GetType() == NotifyEventType::KEYINPUT )
3668 {
3669 KeyEvent aKEvt = *rNEvt.GetKeyEvent();
3670 vcl::KeyCode aKeyCode = aKEvt.GetKeyCode();
3671 sal_uInt16 nKeyCode = aKeyCode.GetCode();
3672 switch( nKeyCode )
3673 {
3674 case KEY_TAB:
3675 {
3676 // internal TAB cycling only if parent is not a dialog or if we are the only child
3677 // otherwise the dialog control will take over
3678 vcl::Window *pParent = ImplGetParent();
3679 bool bOldSchoolContainer =
3680 ((pParent->GetStyle() & (WB_DIALOGCONTROL | WB_NODIALOGCONTROL)) == WB_DIALOGCONTROL &&
3681 pParent->GetChildCount() != 1);
3682 bool bNoTabCycling = bOldSchoolContainer || isContainerWindow(pParent);
3683
3684 if( bNoTabCycling )
3685 return DockingWindow::EventNotify( rNEvt );
3686 else if( ImplChangeHighlightUpDn( aKeyCode.IsShift() , bNoTabCycling ) )
3687 return true;
3688 else
3689 return DockingWindow::EventNotify( rNEvt );
3690 }
3691 default:
3692 break;
3693 }
3694 }
3695 else if( rNEvt.GetType() == NotifyEventType::GETFOCUS )
3696 {
3697 if( rNEvt.GetWindow() == this )
3698 {
3699 // the toolbar itself got the focus
3700 if( mnLastFocusItemId != ToolBoxItemId(0) || mpData->mbMenubuttonWasLastSelected )
3701 {
3702 // restore last item
3703 if( mpData->mbMenubuttonWasLastSelected )
3704 {
3705 ImplChangeHighlight( nullptr );
3706 mpData->mbMenubuttonSelected = true;
3707 InvalidateMenuButton();
3708 }
3709 else
3710 {
3711 ImplChangeHighlight( ImplGetItem( mnLastFocusItemId ) );
3712 mnLastFocusItemId = ToolBoxItemId(0);
3713 }
3714 }
3715 else if( (GetGetFocusFlags() & (GetFocusFlags::Backward|GetFocusFlags::Tab) ) == (GetFocusFlags::Backward|GetFocusFlags::Tab))
3716 // Shift-TAB was pressed in the parent
3717 ImplChangeHighlightUpDn( false );
3718 else
3719 ImplChangeHighlightUpDn( true );
3720
3721 mnLastFocusItemId = ToolBoxItemId(0);
3722
3723 return true;
3724 }
3725 else
3726 {
3727 // a child window got the focus so update current item to
3728 // allow for proper lose focus handling in keyboard navigation
3729 for (auto const& item : mpData->m_aItems)
3730 {
3731 if ( item.mbVisible )
3732 {
3733 if ( item.mpWindow && item.mpWindow->ImplIsWindowOrChild( rNEvt.GetWindow() ) )
3734 {
3735 mnHighItemId = item.mnId;
3736 break;
3737 }
3738 }
3739 }
3740 return DockingWindow::EventNotify( rNEvt );
3741 }
3742 }
3743 else if( rNEvt.GetType() == NotifyEventType::LOSEFOCUS )
3744 {
3745 // deselect
3746 ImplHideFocus();
3747 mpData->mbMenubuttonWasLastSelected = false;
3748 mnHighItemId = ToolBoxItemId(0);
3749 mnCurPos = ITEM_NOTFOUND;
3750 }
3751
3752 return DockingWindow::EventNotify( rNEvt );
3753 }
3754
3755 void ToolBox::Command( const CommandEvent& rCEvt )
3756 {
3757 if ( rCEvt.GetCommand() == CommandEventId::Wheel )
3758 {
3759 if ( (mnCurLine > 1) || (mnCurLine+mnVisLines-1 < mnCurLines) )
3760 {
3761 const CommandWheelData* pData = rCEvt.GetWheelData();
3762 if ( pData->GetMode() == CommandWheelMode::SCROLL )
3763 {
3764 if ( (mnCurLine > 1) && (pData->GetDelta() > 0) )
3765 ShowLine( false );
3766 else if ( (mnCurLine+mnVisLines-1 < mnCurLines) && (pData->GetDelta() < 0) )
3767 ShowLine( true );
3768 InvalidateSpin();
3769 return;
3770 }
3771 }
3772 }
3773 else if ( rCEvt.GetCommand() == CommandEventId::ContextMenu )
3774 {
3775 ExecuteCustomMenu( tools::Rectangle( rCEvt.GetMousePosPixel(), rCEvt.GetMousePosPixel() ) );
3776 return;
3777 }
3778
3779 DockingWindow::Command( rCEvt );
3780 }
3781
3782 void ToolBox::StateChanged( StateChangedType nType )
3783 {
3784 DockingWindow::StateChanged( nType );
3785
3786 if ( nType == StateChangedType::InitShow )
3787 ImplFormat();
3788 else if ( nType == StateChangedType::Enable )
3789 ImplUpdateItem();
3790 else if ( nType == StateChangedType::UpdateMode )
3791 {
3792 if ( IsUpdateMode() )
3793 Invalidate();
3794 }
3795 else if ( (nType == StateChangedType::Zoom) ||
3796 (nType == StateChangedType::ControlFont) )
3797 {
3798 mbCalc = true;
3799 mbFormat = true;
3800 ImplInitSettings( true, false, false );
3801 Invalidate();
3802 }
3803 else if ( nType == StateChangedType::ControlForeground )
3804 {
3805 ImplInitSettings( false, true, false );
3806 Invalidate();
3807 }
3808 else if ( nType == StateChangedType::ControlBackground )
3809 {
3810 ImplInitSettings( false, false, true ); // font, foreground, background
3811 Invalidate();
3812 }
3813
3814 maStateChangedHandler.Call( &nType );
3815 }
3816
3817 void ToolBox::DataChanged( const DataChangedEvent& rDCEvt )
3818 {
3819 DockingWindow::DataChanged( rDCEvt );
3820
3821 if ( (rDCEvt.GetType() == DataChangedEventType::DISPLAY) ||
3822 (rDCEvt.GetType() == DataChangedEventType::FONTS) ||
3823 (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION) ||
3824 ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
3825 (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) )
3826 {
3827 mbCalc = true;
3828 mbFormat = true;
3829 ImplInitSettings( true, true, true );
3830 Invalidate();
3831 }
3832
3833 maDataChangedHandler.Call( &rDCEvt );
3834 }
3835
3836 void ToolBox::SetStyle(WinBits nNewStyle)
3837 {
3838 mnWinStyle = nNewStyle;
3839 if (!ImplIsFloatingMode())
3840 {
3841 bool bOldScroll = mbScroll;
3842 mbScroll = (mnWinStyle & WB_SCROLL) != 0;
3843 if (mbScroll != bOldScroll)
3844 {
3845 mbFormat = true;
3846 ImplFormat();
3847 }
3848 }
3849 }
3850
3851 void ToolBox::ToggleFloatingMode()
3852 {
3853 DockingWindow::ToggleFloatingMode();
3854
3855 if (!mpData)
3856 return;
3857
3858 bool bOldHorz = mbHorz;
3859
3860 if ( ImplIsFloatingMode() )
3861 {
3862 mbHorz = true;
3863 meAlign = WindowAlign::Top;
3864 mbScroll = true;
3865
3866 if( bOldHorz != mbHorz )
3867 mbCalc = true; // orientation was changed !
3868
3869 ImplSetMinMaxFloatSize();
3870 SetOutputSizePixel( ImplCalcFloatSize( mnFloatLines ) );
3871 }
3872 else
3873 {
3874 mbScroll = (mnWinStyle & WB_SCROLL) != 0;
3875 if ( (meAlign == WindowAlign::Top) || (meAlign == WindowAlign::Bottom) )
3876 mbHorz = true;
3877 else
3878 mbHorz = false;
3879
3880 // set focus back to document
3881 ImplGetFrameWindow()->GetWindow( GetWindowType::Client )->GrabFocus();
3882 }
3883
3884 if( bOldHorz != mbHorz )
3885 {
3886 // if orientation changes, the toolbox has to be initialized again
3887 // to update the direction of the gradient
3888 mbCalc = true;
3889 ImplInitSettings( true, true, true );
3890 }
3891
3892 mbFormat = true;
3893 ImplFormat();
3894 }
3895
3896 void ToolBox::StartDocking()
3897 {
3898 meDockAlign = meAlign;
3899 mnDockLines = mnLines;
3900 mbLastFloatMode = ImplIsFloatingMode();
3901 DockingWindow::StartDocking();
3902 }
3903
3904 bool ToolBox::Docking( const Point& rPos, tools::Rectangle& rRect )
3905 {
3906 // do nothing during dragging, it was calculated before
3907 if ( mbDragging )
3908 return false;
3909
3910 bool bFloatMode = false;
3911
3912 DockingWindow::Docking( rPos, rRect );
3913
3914 // if the mouse is outside the area, it can only become a floating window
3915 tools::Rectangle aDockingRect( rRect );
3916 if ( !ImplIsFloatingMode() )
3917 {
3918 // don't use tracking rectangle for alignment check, because it will be too large
3919 // to get a floating mode as result - switch to floating size
3920 // so the calculation only depends on the position of the rectangle, not the current
3921 // docking state of the window
3922 ImplToolItems::size_type nTemp = 0;
3923 aDockingRect.SetSize( ImplCalcFloatSize( nTemp ) );
3924
3925 // in this mode docking is never done by keyboard, so it's OK to use the mouse position
3926 aDockingRect.SetPos( ImplGetFrameWindow()->GetPointerPosPixel() );
3927 }
3928
3929 bFloatMode = true;
3930
3931 meDockAlign = meAlign;
3932 if ( !mbLastFloatMode )
3933 {
3934 ImplToolItems::size_type nTemp = 0;
3935 aDockingRect.SetSize( ImplCalcFloatSize( nTemp ) );
3936 }
3937
3938 rRect = aDockingRect;
3939 mbLastFloatMode = bFloatMode;
3940
3941 return bFloatMode;
3942 }
3943
3944 void ToolBox::EndDocking( const tools::Rectangle& rRect, bool bFloatMode )
3945 {
3946 if ( !IsDockingCanceled() )
3947 {
3948 if ( mnLines != mnDockLines )
3949 SetLineCount( mnDockLines );
3950 if ( meAlign != meDockAlign )
3951 SetAlign( meDockAlign );
3952 }
3953 if ( bFloatMode || (bFloatMode != ImplIsFloatingMode()) )
3954 DockingWindow::EndDocking( rRect, bFloatMode );
3955 }
3956
3957 void ToolBox::Resizing( Size& rSize )
3958 {
3959 ImplToolItems::size_type nCalcLines;
3960 ImplToolItems::size_type nTemp;
3961
3962 // calculate all floating sizes
3963 ImplCalcFloatSizes();
3964
3965 if ( !mnLastResizeDY )
3966 mnLastResizeDY = mnDY;
3967
3968 // is vertical resizing needed
3969 if ( (mnLastResizeDY != rSize.Height()) && (mnDY != rSize.Height()) )
3970 {
3971 nCalcLines = ImplCalcLines( rSize.Height() );
3972 if ( nCalcLines < 1 )
3973 nCalcLines = 1;
3974 rSize = ImplCalcFloatSize( nCalcLines );
3975 }
3976 else
3977 {
3978 nCalcLines = 1;
3979 nTemp = nCalcLines;
3980 Size aTempSize = ImplCalcFloatSize( nTemp );
3981 while ( (aTempSize.Width() > rSize.Width()) &&
3982 (nCalcLines <= maFloatSizes[0].mnLines) )
3983 {
3984 nCalcLines++;
3985 nTemp = nCalcLines;
3986 aTempSize = ImplCalcFloatSize( nTemp );
3987 }
3988 rSize = aTempSize;
3989 }
3990
3991 mnLastResizeDY = rSize.Height();
3992 }
3993
3994 Size ToolBox::GetOptimalSize() const
3995 {
3996 // If we have any expandable entries, then force them to their
3997 // optimal sizes, then reset them afterwards
3998 std::map<vcl::Window*, Size> aExpandables;
3999 for (const ImplToolItem & rItem : mpData->m_aItems)
4000 {
4001 if (rItem.mbExpand)
4002 {
4003 vcl::Window *pWindow = rItem.mpWindow;
4004 SAL_INFO_IF(!pWindow, "vcl.layout", "only tabitems with window supported at the moment");
4005 if (!pWindow)
4006 continue;
4007 Size aWinSize(pWindow->GetSizePixel());
4008 aExpandables[pWindow] = aWinSize;
4009 Size aPrefSize(pWindow->get_preferred_size());
4010 aWinSize.setWidth( aPrefSize.Width() );
4011 pWindow->SetSizePixel(aWinSize);
4012 }
4013 }
4014
4015 Size aSize(const_cast<ToolBox *>(this)->ImplCalcSize( mnLines ));
4016
4017 for (auto const& [pWindow, aWinSize] : aExpandables)
4018 pWindow->SetSizePixel(aWinSize);
4019
4020 return aSize;
4021 }
4022
4023 Size ToolBox::CalcWindowSizePixel( ImplToolItems::size_type nCalcLines )
4024 {
4025 return ImplCalcSize( nCalcLines );
4026 }
4027
4028 Size ToolBox::CalcWindowSizePixel( ImplToolItems::size_type nCalcLines, WindowAlign eAlign )
4029 {
4030 return ImplCalcSize( nCalcLines,
4031 (eAlign == WindowAlign::Top || eAlign == WindowAlign::Bottom) ? TB_CALCMODE_HORZ : TB_CALCMODE_VERT );
4032 }
4033
4034 ToolBox::ImplToolItems::size_type ToolBox::ImplCountLineBreaks() const
4035 {
4036 ImplToolItems::size_type nLines = 0;
4037
4038 for (auto const& item : mpData->m_aItems)
4039 {
4040 if( item.meType == ToolBoxItemType::BREAK )
4041 ++nLines;
4042 }
4043 return nLines;
4044 }
4045
4046 Size ToolBox::CalcPopupWindowSizePixel()
4047 {
4048 // count number of breaks and calc corresponding floating window size
4049 ImplToolItems::size_type nLines = ImplCountLineBreaks();
4050
4051 if( nLines )
4052 ++nLines; // add the first line
4053 else
4054 {
4055 // no breaks found: use quadratic layout
4056 nLines = static_cast<ImplToolItems::size_type>(ceil( sqrt( static_cast<double>(GetItemCount()) ) ));
4057 }
4058
4059 bool bPopup = mpData->mbAssumePopupMode;
4060 mpData->mbAssumePopupMode = true;
4061
4062 Size aSize = CalcFloatingWindowSizePixel( nLines );
4063
4064 mpData->mbAssumePopupMode = bPopup;
4065 return aSize;
4066 }
4067
4068 Size ToolBox::CalcFloatingWindowSizePixel()
4069 {
4070 ImplToolItems::size_type nLines = ImplCountLineBreaks();
4071 ++nLines; // add the first line
4072 return CalcFloatingWindowSizePixel( nLines );
4073 }
4074
4075 Size ToolBox::CalcFloatingWindowSizePixel( ImplToolItems::size_type nCalcLines )
4076 {
4077 bool bFloat = mpData->mbAssumeFloating;
4078 bool bDocking = mpData->mbAssumeDocked;
4079
4080 // simulate floating mode and force reformat before calculating
4081 mpData->mbAssumeFloating = true;
4082 mpData->mbAssumeDocked = false;
4083
4084 Size aSize = ImplCalcFloatSize( nCalcLines );
4085
4086 mbFormat = true;
4087 mpData->mbAssumeFloating = bFloat;
4088 mpData->mbAssumeDocked = bDocking;
4089
4090 return aSize;
4091 }
4092
4093 Size ToolBox::CalcMinimumWindowSizePixel()
4094 {
4095 if( ImplIsFloatingMode() )
4096 return ImplCalcSize( mnFloatLines );
4097 else
4098 {
4099 // create dummy toolbox for measurements
4100 VclPtrInstance< ToolBox > pToolBox( GetParent(), GetStyle() );
4101
4102 // copy until first useful item
4103 for (auto const& item : mpData->m_aItems)
4104 {
4105 pToolBox->CopyItem( *this, item.mnId );
4106 if( (item.meType == ToolBoxItemType::BUTTON) &&
4107 item.mbVisible && !ImplIsFixedControl( &item ) )
4108 break;
4109 }
4110
4111 // add to docking manager if required to obtain a drag area
4112 // (which is accounted for in calcwindowsizepixel)
4113 if( ImplGetDockingManager()->GetDockingWindowWrapper( this ) )
4114 ImplGetDockingManager()->AddWindow( pToolBox );
4115
4116 // account for menu
4117 if( IsMenuEnabled() )
4118 pToolBox->SetMenuType( GetMenuType() );
4119
4120 pToolBox->SetAlign( GetAlign() );
4121 Size aSize = pToolBox->CalcWindowSizePixel( 1 );
4122
4123 ImplGetDockingManager()->RemoveWindow( pToolBox );
4124 pToolBox->Clear();
4125
4126 pToolBox.disposeAndClear();
4127
4128 return aSize;
4129 }
4130 }
4131
4132 void ToolBox::EnableCustomize( bool bEnable )
4133 {
4134 mbCustomize = bEnable;
4135 }
4136
4137 void ToolBox::LoseFocus()
4138 {
4139 ImplChangeHighlight( nullptr, true );
4140
4141 DockingWindow::LoseFocus();
4142 }
4143
4144 // performs the action associated with an item, ie simulates clicking the item
4145 void ToolBox::TriggerItem( ToolBoxItemId nItemId )
4146 {
4147 mnHighItemId = nItemId;
4148 vcl::KeyCode aKeyCode( 0, 0 );
4149 ImplActivateItem( aKeyCode );
4150 }
4151
4152 bool ToolBox::ItemHasDropdown( ToolBoxItemId nItemId )
4153 {
4154 ImplToolItem* pItem = ImplGetItem( nItemId );
4155 return pItem && pItem->mnBits & ToolBoxItemBits::DROPDOWN;
4156 }
4157
4158 void ToolBox::TriggerItemDropdown( ToolBoxItemId nItemId )
4159 {
4160 if( mpFloatWin || !ItemHasDropdown( nItemId ) )
4161 return;
4162
4163 // Prevent highlighting of triggered item
4164 mnHighItemId = ToolBoxItemId(0);
4165
4166 mnDownItemId = mnCurItemId = nItemId;
4167 mnCurPos = GetItemPos( mnCurItemId );
4168 mnMouseModifier = 0;
4169
4170 mpData->mbDropDownByKeyboard = false;
4171 mpData->maDropdownClickHdl.Call( this );
4172 }
4173
4174 // calls the button's action handler
4175 // returns true if action was called
4176 bool ToolBox::ImplActivateItem( vcl::KeyCode aKeyCode )
4177 {
4178 bool bRet = true;
4179 if( mnHighItemId )
4180 {
4181 ImplToolItem *pToolItem = ImplGetItem( mnHighItemId );
4182
4183 // #107712#, activate can also be called for disabled entries
4184 if( pToolItem && !pToolItem->mbEnabled )
4185 return true;
4186
4187 if( pToolItem && pToolItem->mpWindow && HasFocus() )
4188 {
4189 ImplHideFocus();
4190 mbChangingHighlight = true; // avoid focus change due to loss of focus
4191 pToolItem->mpWindow->ImplControlFocus( GetFocusFlags::Tab );
4192 mbChangingHighlight = false;
4193 }
4194 else
4195 {
4196 mnDownItemId = mnCurItemId = mnHighItemId;
4197 if (pToolItem && (pToolItem->mnBits & ToolBoxItemBits::AUTOCHECK))
4198 {
4199 if ( pToolItem->mnBits & ToolBoxItemBits::RADIOCHECK )
4200 {
4201 if ( pToolItem->meState != TRISTATE_TRUE )
4202 SetItemState( pToolItem->mnId, TRISTATE_TRUE );
4203 }
4204 else
4205 {
4206 if ( pToolItem->meState != TRISTATE_TRUE )
4207 pToolItem->meState = TRISTATE_TRUE;
4208 else
4209 pToolItem->meState = TRISTATE_FALSE;
4210 }
4211 }
4212 mnMouseModifier = aKeyCode.GetModifier();
4213 mbIsKeyEvent = true;
4214 Activate();
4215 Click();
4216
4217 // #107776# we might be destroyed in the selecthandler
4218 VclPtr<vcl::Window> xWindow = this;
4219 Select();
4220 if ( xWindow->isDisposed() )
4221 return bRet;
4222
4223 Deactivate();
4224 mbIsKeyEvent = false;
4225 mnMouseModifier = 0;
4226 }
4227 }
4228 else
4229 bRet = false;
4230 return bRet;
4231 }
4232
4233 static bool ImplCloseLastPopup( vcl::Window const *pParent )
4234 {
4235 // close last popup toolbox (see also:
4236 // ImplHandleMouseFloatMode(...) in winproc.cxx )
4237
4238 if (ImplGetSVData()->mpWinData->mpFirstFloat)
4239 {
4240 FloatingWindow* pLastLevelFloat = ImplGetSVData()->mpWinData->mpFirstFloat->ImplFindLastLevelFloat();
4241 // only close the floater if it is not our direct parent, which would kill ourself
4242 if( pLastLevelFloat && pLastLevelFloat != pParent )
4243 {
4244 pLastLevelFloat->EndPopupMode( FloatWinPopupEndFlags::Cancel | FloatWinPopupEndFlags::CloseAll );
4245 return true;
4246 }
4247 }
4248 return false;
4249 }
4250
4251 // opens a drop down toolbox item
4252 // returns true if item was opened
4253 bool ToolBox::ImplOpenItem( vcl::KeyCode aKeyCode )
4254 {
4255 sal_uInt16 nCode = aKeyCode.GetCode();
4256 bool bRet = true;
4257
4258 // arrow keys should work only in the opposite direction of alignment (to not break cursor travelling)
4259 if ( ((nCode == KEY_LEFT || nCode == KEY_RIGHT) && IsHorizontal())
4260 || ((nCode == KEY_UP || nCode == KEY_DOWN) && !IsHorizontal()) )
4261 return false;
4262
4263 if( mpData->mbMenubuttonSelected )
4264 {
4265 if( ImplCloseLastPopup( GetParent() ) )
4266 return bRet;
4267 mbIsKeyEvent = true;
4268 if ( maMenuButtonHdl.IsSet() )
4269 maMenuButtonHdl.Call( this );
4270 else
4271 ExecuteCustomMenu( mpData->maMenubuttonItem.maRect );
4272 mpData->mbMenubuttonWasLastSelected = true;
4273 mbIsKeyEvent = false;
4274 }
4275 else if( mnHighItemId && ImplGetItem( mnHighItemId ) &&
4276 (ImplGetItem( mnHighItemId )->mnBits & ToolBoxItemBits::DROPDOWN) )
4277 {
4278 mnDownItemId = mnCurItemId = mnHighItemId;
4279 mnCurPos = GetItemPos( mnCurItemId );
4280 mnLastFocusItemId = mnCurItemId; // save item id for possible later focus restore
4281 mnMouseModifier = aKeyCode.GetModifier();
4282 mbIsKeyEvent = true;
4283 Activate();
4284
4285 mpData->mbDropDownByKeyboard = true;
4286 mpData->maDropdownClickHdl.Call( this );
4287
4288 mbIsKeyEvent = false;
4289 mnMouseModifier = 0;
4290 }
4291 else
4292 bRet = false;
4293
4294 return bRet;
4295 }
4296
4297 void ToolBox::KeyInput( const KeyEvent& rKEvt )
4298 {
4299 vcl::KeyCode aKeyCode = rKEvt.GetKeyCode();
4300 sal_uInt16 nCode = aKeyCode.GetCode();
4301
4302 vcl::Window *pParent = ImplGetParent();
4303 bool bOldSchoolContainer = ((pParent->GetStyle() & (WB_DIALOGCONTROL | WB_NODIALOGCONTROL)) == WB_DIALOGCONTROL);
4304 bool bParentIsContainer = bOldSchoolContainer || isContainerWindow(pParent);
4305
4306 bool bForwardKey = false;
4307 bool bGrabFocusToDocument = false;
4308
4309 // #107776# we might be destroyed in the keyhandler
4310 VclPtr<vcl::Window> xWindow = this;
4311
4312 switch ( nCode )
4313 {
4314 case KEY_UP:
4315 {
4316 // Ctrl-Cursor activates next toolbox, indicated by a blue arrow pointing to the left/up
4317 if( aKeyCode.GetModifier() ) // allow only pure cursor keys
4318 break;
4319 if( !IsHorizontal() )
4320 ImplChangeHighlightUpDn( true );
4321 else
4322 ImplOpenItem( aKeyCode );
4323 }
4324 break;
4325 case KEY_LEFT:
4326 {
4327 if( aKeyCode.GetModifier() ) // allow only pure cursor keys
4328 break;
4329 if( IsHorizontal() )
4330 ImplChangeHighlightUpDn( true );
4331 else
4332 ImplOpenItem( aKeyCode );
4333 }
4334 break;
4335 case KEY_DOWN:
4336 {
4337 if( aKeyCode.GetModifier() ) // allow only pure cursor keys
4338 break;
4339 if( !IsHorizontal() )
4340 ImplChangeHighlightUpDn( false );
4341 else
4342 ImplOpenItem( aKeyCode );
4343 }
4344 break;
4345 case KEY_RIGHT:
4346 {
4347 if( aKeyCode.GetModifier() ) // allow only pure cursor keys
4348 break;
4349 if( IsHorizontal() )
4350 ImplChangeHighlightUpDn( false );
4351 else
4352 ImplOpenItem( aKeyCode );
4353 }
4354 break;
4355 case KEY_PAGEUP:
4356 if ( mnCurLine > 1 )
4357 {
4358 if( mnCurLine > mnVisLines )
4359 mnCurLine = mnCurLine - mnVisLines;
4360 else
4361 mnCurLine = 1;
4362 mbFormat = true;
4363 ImplFormat();
4364 InvalidateSpin();
4365 ImplChangeHighlight( ImplGetFirstValidItem( mnCurLine ) );
4366 }
4367 break;
4368 case KEY_PAGEDOWN:
4369 if ( mnCurLine+mnVisLines-1 < mnCurLines )
4370 {
4371 if( mnCurLine + 2*mnVisLines-1 < mnCurLines )
4372 mnCurLine = mnCurLine + mnVisLines;
4373 else
4374 mnCurLine = mnCurLines;
4375 mbFormat = true;
4376 ImplFormat();
4377 InvalidateSpin();
4378 ImplChangeHighlight( ImplGetFirstValidItem( mnCurLine ) );
4379 }
4380 break;
4381 case KEY_END:
4382 {
4383 ImplChangeHighlight( nullptr );
4384 ImplChangeHighlightUpDn( false );
4385 }
4386 break;
4387 case KEY_HOME:
4388 {
4389 ImplChangeHighlight( nullptr );
4390 ImplChangeHighlightUpDn( true );
4391 }
4392 break;
4393 case KEY_ESCAPE:
4394 {
4395 if( !ImplIsFloatingMode() && bParentIsContainer )
4396 DockingWindow::KeyInput( rKEvt );
4397 else
4398 {
4399 // send focus to document pane
4400 vcl::Window *pWin = this;
4401 while( pWin )
4402 {
4403 if( !pWin->GetParent() )
4404 {
4405 pWin->ImplGetFrameWindow()->GetWindow( GetWindowType::Client )->GrabFocus();
4406 break;
4407 }
4408 pWin = pWin->GetParent();
4409 }
4410 }
4411 }
4412 break;
4413 case KEY_RETURN:
4414 {
4415 // #107712#, disabled entries are selectable now
4416 // leave toolbox and move focus to document
4417 if( mnHighItemId )
4418 {
4419 ImplToolItem *pItem = ImplGetItem(mnHighItemId);
4420 if (!pItem || !pItem->mbEnabled)
4421 {
4422 bGrabFocusToDocument = true;
4423 }
4424 }
4425 if( !bGrabFocusToDocument )
4426 bForwardKey = !ImplActivateItem( aKeyCode );
4427 }
4428 break;
4429 case KEY_SPACE:
4430 {
4431 ImplOpenItem( aKeyCode );
4432 }
4433 break;
4434 default:
4435 {
4436 sal_uInt16 aKeyGroup = aKeyCode.GetGroup();
4437 ImplToolItem *pItem = nullptr;
4438 if( mnHighItemId )
4439 pItem = ImplGetItem( mnHighItemId );
4440 // #i13931# forward alphanum keyinput into embedded control
4441 if( (aKeyGroup == KEYGROUP_NUM || aKeyGroup == KEYGROUP_ALPHA ) && pItem && pItem->mpWindow && pItem->mbEnabled )
4442 {
4443 vcl::Window *pFocusWindow = Application::GetFocusWindow();
4444 ImplHideFocus();
4445 mbChangingHighlight = true; // avoid focus change due to loss of focus
4446 pItem->mpWindow->ImplControlFocus( GetFocusFlags::Tab );
4447 mbChangingHighlight = false;
4448 if( pFocusWindow != Application::GetFocusWindow() )
4449 Application::GetFocusWindow()->KeyInput( rKEvt );
4450 }
4451 else
4452 {
4453 // do nothing to avoid key presses going into the document
4454 // while the toolbox has the focus
4455 // just forward function and special keys and combinations with Alt-key
4456 // and Ctrl-key
4457 if( aKeyGroup == KEYGROUP_FKEYS || aKeyGroup == KEYGROUP_MISC || aKeyCode.IsMod2()
4458 || aKeyCode.IsMod1() )
4459 bForwardKey = true;
4460 }
4461 }
4462 }
4463
4464 if ( xWindow->isDisposed() )
4465 return;
4466
4467 // #107251# move focus away if this toolbox was disabled during keyinput
4468 if (HasFocus() && mpData->mbKeyInputDisabled && bParentIsContainer)
4469 {
4470 vcl::Window *pFocusControl = pParent->ImplGetDlgWindow( 0, GetDlgWindowType::First );
4471 if ( pFocusControl && pFocusControl != this )
4472 pFocusControl->ImplControlFocus( GetFocusFlags::Init );
4473 }
4474
4475 // #107712#, leave toolbox
4476 if( bGrabFocusToDocument )
4477 {
4478 GrabFocusToDocument();
4479 return;
4480 }
4481
4482 if( bForwardKey )
4483 DockingWindow::KeyInput( rKEvt );
4484 }
4485
4486 // returns the current toolbox line of the item
4487 ToolBox::ImplToolItems::size_type ToolBox::ImplGetItemLine( ImplToolItem const * pCurrentItem )
4488 {
4489 ImplToolItems::size_type nLine = 1;
4490 for (auto const& item : mpData->m_aItems)
4491 {
4492 if ( item.mbBreak )
4493 ++nLine;
4494 if( &item == pCurrentItem)
4495 break;
4496 }
4497 return nLine;
4498 }
4499
4500 // returns the first displayable item in the given line
4501 ImplToolItem* ToolBox::ImplGetFirstValidItem( ImplToolItems::size_type nLine )
4502 {
4503 if( !nLine || nLine > mnCurLines )
4504 return nullptr;
4505
4506 nLine--;
4507
4508 ImplToolItems::iterator it = mpData->m_aItems.begin();
4509 while( it != mpData->m_aItems.end() )
4510 {
4511 // find correct line
4512 if ( it->mbBreak )
4513 nLine--;
4514 if( !nLine )
4515 {
4516 // find first useful item
4517 while( it != mpData->m_aItems.end() && ((it->meType != ToolBoxItemType::BUTTON) ||
4518 /*!it->mbEnabled ||*/ !it->mbVisible || ImplIsFixedControl( &(*it) )) )
4519 {
4520 ++it;
4521 if( it == mpData->m_aItems.end() || it->mbBreak )
4522 return nullptr; // no valid items in this line
4523 }
4524 return &(*it);
4525 }
4526 ++it;
4527 }
4528
4529 return (it == mpData->m_aItems.end()) ? nullptr : &(*it);
4530 }
4531
4532 ToolBox::ImplToolItems::size_type ToolBox::ImplFindItemPos( const ImplToolItem* pItem, const ImplToolItems& rList )
4533 {
4534 if( pItem )
4535 {
4536 for( ImplToolItems::size_type nPos = 0; nPos < rList.size(); ++nPos )
4537 if( &rList[ nPos ] == pItem )
4538 return nPos;
4539 }
4540 return ITEM_NOTFOUND;
4541 }
4542
4543 void ToolBox::ChangeHighlight( ImplToolItems::size_type nPos )
4544 {
4545 if ( nPos < GetItemCount() ) {
4546 ImplGrabFocus( GetFocusFlags::NONE );
4547 ImplChangeHighlight ( ImplGetItem ( GetItemId ( nPos ) ) );
4548 }
4549 }
4550
4551 void ToolBox::ImplChangeHighlight( ImplToolItem const * pItem, bool bNoGrabFocus )
4552 {
4553 // avoid recursion due to focus change
4554 if( mbChangingHighlight )
4555 return;
4556
4557 mbChangingHighlight = true;
4558
4559 ImplToolItem* pOldItem = nullptr;
4560
4561 if ( mnHighItemId )
4562 {
4563 ImplHideFocus();
4564 ImplToolItems::size_type nPos = GetItemPos( mnHighItemId );
4565 pOldItem = ImplGetItem( mnHighItemId );
4566 // #i89962# ImplDrawItem can cause Invalidate/Update
4567 // which will in turn ImplShowFocus again
4568 // set mnHighItemId to 0 already to prevent this hen/egg problem
4569 mnHighItemId = ToolBoxItemId(0);
4570 InvalidateItem(nPos);
4571 CallEventListeners( VclEventId::ToolboxHighlightOff, reinterpret_cast< void* >( nPos ) );
4572 }
4573
4574 if( !bNoGrabFocus && pItem != pOldItem && pOldItem && pOldItem->mpWindow )
4575 {
4576 // move focus into toolbox
4577 GrabFocus();
4578 }
4579
4580 if( pItem )
4581 {
4582 ImplToolItems::size_type aPos = ToolBox::ImplFindItemPos( pItem, mpData->m_aItems );
4583 if( aPos != ITEM_NOTFOUND)
4584 {
4585 // check for line breaks
4586 ImplToolItems::size_type nLine = ImplGetItemLine( pItem );
4587
4588 if( nLine >= mnCurLine + mnVisLines )
4589 {
4590 mnCurLine = nLine - mnVisLines + 1;
4591 mbFormat = true;
4592 }
4593 else if ( nLine < mnCurLine )
4594 {
4595 mnCurLine = nLine;
4596 mbFormat = true;
4597 }
4598
4599 if( mbFormat )
4600 {
4601 ImplFormat();
4602 }
4603
4604 mnHighItemId = pItem->mnId;
4605 InvalidateItem(aPos);
4606
4607 ImplShowFocus();
4608
4609 if( pItem->mpWindow )
4610 pItem->mpWindow->GrabFocus();
4611 if( pItem != pOldItem )
4612 CallEventListeners( VclEventId::ToolboxHighlight );
4613 }
4614 }
4615 else
4616 {
4617 ImplHideFocus();
4618 mnHighItemId = ToolBoxItemId(0);
4619 mnCurPos = ITEM_NOTFOUND;
4620 }
4621
4622 mbChangingHighlight = false;
4623 }
4624
4625 // check for keyboard accessible items
4626 static bool ImplIsValidItem( const ImplToolItem* pItem, bool bNotClipped )
4627 {
4628 bool bValid = (pItem && pItem->meType == ToolBoxItemType::BUTTON && pItem->mbVisible && !ImplIsFixedControl( pItem )
4629 && pItem->mbEnabled);
4630 if( bValid && bNotClipped && pItem->IsClipped() )
4631 bValid = false;
4632 return bValid;
4633 }
4634
4635 bool ToolBox::ImplChangeHighlightUpDn( bool bUp, bool bNoCycle )
4636 {
4637 ImplToolItem* pToolItem = ImplGetItem( mnHighItemId );
4638
4639 if( !pToolItem || !mnHighItemId )
4640 {
4641 // menubutton highlighted ?
4642 if( mpData->mbMenubuttonSelected )
4643 {
4644 mpData->mbMenubuttonSelected = false;
4645 if( bUp )
4646 {
4647 // select last valid non-clipped item
4648 ImplToolItem* pItem = nullptr;
4649 auto it = std::find_if(mpData->m_aItems.rbegin(), mpData->m_aItems.rend(),
4650 [](const ImplToolItem& rItem) { return ImplIsValidItem( &rItem, true ); });
4651 if( it != mpData->m_aItems.rend() )
4652 pItem = &(*it);
4653
4654 InvalidateMenuButton();
4655 ImplChangeHighlight( pItem );
4656 }
4657 else
4658 {
4659 // select first valid non-clipped item
4660 ImplToolItems::iterator it = std::find_if(mpData->m_aItems.begin(), mpData->m_aItems.end(),
4661 [](const ImplToolItem& rItem) { return ImplIsValidItem( &rItem, true ); });
4662 if( it != mpData->m_aItems.end() )
4663 {
4664 InvalidateMenuButton();
4665 ImplChangeHighlight( &(*it) );
4666 }
4667 }
4668 return true;
4669 }
4670
4671 if( bUp )
4672 {
4673 // Select first valid item
4674 ImplToolItems::iterator it = std::find_if(mpData->m_aItems.begin(), mpData->m_aItems.end(),
4675 [](const ImplToolItem& rItem) { return ImplIsValidItem( &rItem, false ); });
4676
4677 // select the menu button if a clipped item would be selected
4678 if( (it != mpData->m_aItems.end() && &(*it) == ImplGetFirstClippedItem()) && IsMenuEnabled() )
4679 {
4680 ImplChangeHighlight( nullptr );
4681 mpData->mbMenubuttonSelected = true;
4682 InvalidateMenuButton();
4683 }
4684 else
4685 ImplChangeHighlight( (it != mpData->m_aItems.end()) ? &(*it) : nullptr );
4686 return true;
4687 }
4688 else
4689 {
4690 // Select last valid item
4691
4692 // docked toolbars have the menubutton as last item - if this button is enabled
4693 if( ImplHasClippedItems() && IsMenuEnabled() && !ImplIsFloatingMode() )
4694 {
4695 ImplChangeHighlight( nullptr );
4696 mpData->mbMenubuttonSelected = true;
4697 InvalidateMenuButton();
4698 }
4699 else
4700 {
4701 ImplToolItem* pItem = nullptr;
4702 auto it = std::find_if(mpData->m_aItems.rbegin(), mpData->m_aItems.rend(),
4703 [](const ImplToolItem& rItem) { return ImplIsValidItem( &rItem, false ); });
4704 if( it != mpData->m_aItems.rend() )
4705 pItem = &(*it);
4706
4707 ImplChangeHighlight( pItem );
4708 }
4709 return true;
4710 }
4711 }
4712
4713 assert(pToolItem);
4714
4715 ImplToolItems::size_type pos = ToolBox::ImplFindItemPos( pToolItem, mpData->m_aItems );
4716 ImplToolItems::size_type nCount = mpData->m_aItems.size();
4717
4718 ImplToolItems::size_type i=0;
4719 do
4720 {
4721 if( bUp )
4722 {
4723 if( !pos-- )
4724 {
4725 if( bNoCycle )
4726 return false;
4727
4728 // highlight the menu button if it is the last item
4729 if( ImplHasClippedItems() && IsMenuEnabled() && !ImplIsFloatingMode() )
4730 {
4731 ImplChangeHighlight( nullptr );
4732 mpData->mbMenubuttonSelected = true;
4733 InvalidateMenuButton();
4734 return true;
4735 }
4736 else
4737 pos = nCount-1;
4738 }
4739 }
4740 else
4741 {
4742 if( ++pos >= nCount )
4743 {
4744 if( bNoCycle )
4745 return false;
4746
4747 // highlight the menu button if it is the last item
4748 if( ImplHasClippedItems() && IsMenuEnabled() && !ImplIsFloatingMode() )
4749 {
4750 ImplChangeHighlight( nullptr );
4751 mpData->mbMenubuttonSelected = true;
4752 InvalidateMenuButton();
4753 return true;
4754 }
4755 else
4756 pos = 0;
4757 }
4758 }
4759
4760 pToolItem = &mpData->m_aItems[pos];
4761
4762 if ( ImplIsValidItem( pToolItem, false ) )
4763 break;
4764
4765 } while( ++i < nCount);
4766
4767 if( pToolItem->IsClipped() && IsMenuEnabled() )
4768 {
4769 // select the menu button if a clipped item would be selected
4770 ImplChangeHighlight( nullptr );
4771 mpData->mbMenubuttonSelected = true;
4772 InvalidateMenuButton();
4773 }
4774 else if( i != nCount )
4775 ImplChangeHighlight( pToolItem );
4776 else
4777 return false;
4778
4779 return true;
4780 }
4781
4782 void ToolBox::ImplShowFocus()
4783 {
4784 if( mnHighItemId && HasFocus() )
4785 {
4786 ImplToolItem* pItem = ImplGetItem( mnHighItemId );
4787 if (pItem && pItem->mpWindow && !pItem->mpWindow->isDisposed())
4788 {
4789 vcl::Window *pWin = pItem->mpWindow->ImplGetWindowImpl()->mpBorderWindow ? pItem->mpWindow->ImplGetWindowImpl()->mpBorderWindow.get() : pItem->mpWindow.get();
4790 pWin->ImplGetWindowImpl()->mbDrawSelectionBackground = true;
4791 pWin->Invalidate();
4792 }
4793 }
4794 }
4795
4796 void ToolBox::ImplHideFocus()
4797 {
4798 if( mnHighItemId )
4799 {
4800 mpData->mbMenubuttonWasLastSelected = false;
4801 ImplToolItem* pItem = ImplGetItem( mnHighItemId );
4802 if( pItem && pItem->mpWindow )
4803 {
4804 vcl::Window *pWin = pItem->mpWindow->ImplGetWindowImpl()->mpBorderWindow ? pItem->mpWindow->ImplGetWindowImpl()->mpBorderWindow.get() : pItem->mpWindow.get();
4805 pWin->ImplGetWindowImpl()->mbDrawSelectionBackground = false;
4806 pWin->Invalidate();
4807 }
4808 }
4809
4810 if ( mpData && mpData->mbMenubuttonSelected )
4811 {
4812 mpData->mbMenubuttonWasLastSelected = true;
4813 // remove highlight from menubutton
4814 mpData->mbMenubuttonSelected = false;
4815 InvalidateMenuButton();
4816 }
4817 }
4818
4819 void ToolBox::SetToolbarLayoutMode( ToolBoxLayoutMode eLayout )
4820 {
4821 if ( meLayoutMode != eLayout )
4822 meLayoutMode = eLayout;
4823 }
4824
4825 void ToolBox::SetToolBoxTextPosition( ToolBoxTextPosition ePosition )
4826 {
4827 meTextPosition = ePosition;
4828 }
4829
4830 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE