?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tdf#130857 qt weld: Implement QtInstanceWidget::strip_mnemonic
[LibreOffice.git] / sc / source / ui / view / tabview.cxx
blob03258c9fdaf293c50c8666ef567a07d0c0688cc1
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 <scitems.hxx>
21 #include <sfx2/viewfrm.hxx>
22 #include <sfx2/bindings.hxx>
23 #include <vcl/commandevent.hxx>
24 #include <vcl/help.hxx>
25 #include <vcl/settings.hxx>
26 #include <vcl/cursor.hxx>
27 #include <sal/log.hxx>
28 #include <tools/svborder.hxx>
29 #include <tools/json_writer.hxx>
30 #include <o3tl/unit_conversion.hxx>
31
32 #include <pagedata.hxx>
33 #include <tabview.hxx>
34 #include <tabvwsh.hxx>
35 #include <document.hxx>
36 #include <gridwin.hxx>
37 #include <olinewin.hxx>
38 #include <olinetab.hxx>
39 #include <tabsplit.hxx>
40 #include <colrowba.hxx>
41 #include <tabcont.hxx>
42 #include <scmod.hxx>
43 #include <sc.hrc>
44 #include <strings.hrc>
45 #include <globstr.hrc>
46 #include <scresid.hxx>
47 #include <drawview.hxx>
48 #include <docsh.hxx>
49 #include <viewuno.hxx>
50 #include <appoptio.hxx>
51 #include <attrib.hxx>
52 #include <spellcheckcontext.hxx>
53 #include <comphelper/lok.hxx>
54 #include <sfx2/lokhelper.hxx>
55 #include <osl/diagnose.h>
56
57 #include <boost/property_tree/ptree.hpp>
58 #include <boost/property_tree/json_parser.hpp>
59
60 #include <com/sun/star/sheet/DataPilotFieldOrientation.hpp>
61
62 #include <algorithm>
63
64 #include <basegfx/utils/zoomtools.hxx>
65
66 #define SPLIT_MARGIN 30
67 #define SPLIT_HANDLE_SIZE 5
68 constexpr sal_Int32 TAB_HEIGHT_MARGIN = 10;
69
70 #define SC_ICONSIZE 36
71
72 #define SC_SCROLLBAR_MIN 30
73 #define SC_TABBAR_MIN 6
74
75 using namespace ::com::sun::star;
76
77 // Corner-Button
78
79 ScCornerButton::ScCornerButton( vcl::Window* pParent, ScViewData* pData ) :
80 Window( pParent, WinBits( 0 ) ),
81 pViewData( pData )
82 {
83 ScCornerButton::EnableRTL( false );
84 SetQuickHelpText(ScResId(SCSTR_QHELP_SELECT_ALL_CELLS));
85 }
86
87 ScCornerButton::~ScCornerButton()
88 {
89 }
90
91 void ScCornerButton::Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
92 {
93 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
94 SetBackground(rStyleSettings.GetFaceColor());
95
96 Size aSize(GetOutputSizePixel());
97 tools::Long nPosX = aSize.Width() - 1;
98 tools::Long nPosY = aSize.Height() - 1;
99
100 Window::Paint(rRenderContext, rRect);
101
102 bool bLayoutRTL = pViewData->GetDocument().IsLayoutRTL( pViewData->GetTabNo() );
103 tools::Long nDarkX = bLayoutRTL ? 0 : nPosX;
104
105 // both buttons have the same look now - only dark right/bottom lines
106 rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
107 rRenderContext.DrawLine(Point(0, nPosY), Point(nPosX, nPosY));
108 rRenderContext.DrawLine(Point(nDarkX, 0), Point(nDarkX, nPosY));
109 }
110
111 void ScCornerButton::StateChanged( StateChangedType nType )
112 {
113 Window::StateChanged( nType );
114
115 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
116 SetBackground( rStyleSettings.GetFaceColor() );
117 Invalidate();
118 }
119
120 void ScCornerButton::DataChanged( const DataChangedEvent& rDCEvt )
121 {
122 Window::DataChanged( rDCEvt );
123
124 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
125 SetBackground( rStyleSettings.GetFaceColor() );
126 Invalidate();
127 }
128
129 void ScCornerButton::Resize()
130 {
131 Invalidate();
132 }
133
134 void ScCornerButton::MouseButtonDown( const MouseEvent& rMEvt )
135 {
136 ScModule* pScMod = ScModule::get();
137 bool bDisable = pScMod->IsFormulaMode() || pScMod->IsModalMode();
138 if (!bDisable)
139 {
140 ScTabViewShell* pViewSh = pViewData->GetViewShell();
141 pViewSh->SetActive(); // Appear and SetViewFrame
142 pViewSh->ActiveGrabFocus();
143
144 bool bControl = rMEvt.IsMod1();
145 pViewSh->SelectAll( bControl );
146 }
147 }
148 namespace
149 {
150
151 bool lcl_HasColOutline( const ScViewData& rViewData )
152 {
153 const ScOutlineTable* pTable = rViewData.GetDocument().GetOutlineTable(rViewData.GetTabNo());
154 if (pTable)
155 {
156 const ScOutlineArray& rArray = pTable->GetColArray();
157 if ( rArray.GetDepth() > 0 )
158 return true;
159 }
160 return false;
161 }
162
163 bool lcl_HasRowOutline( const ScViewData& rViewData )
164 {
165 const ScOutlineTable* pTable = rViewData.GetDocument().GetOutlineTable(rViewData.GetTabNo());
166 if (pTable)
167 {
168 const ScOutlineArray& rArray = pTable->GetRowArray();
169 if ( rArray.GetDepth() > 0 )
170 return true;
171 }
172 return false;
173 }
174
175 } // anonymous namespace
176
177 ScTabView::ScTabView( vcl::Window* pParent, ScDocShell& rDocSh, ScTabViewShell* pViewShell ) :
178 pFrameWin( pParent ),
179 aViewData( rDocSh, pViewShell ),
180 aFunctionSet( &aViewData ),
181 aHdrFunc( &aViewData ),
182 aVScrollTop( VclPtr<ScrollAdaptor>::Create( pFrameWin, false ) ),
183 aVScrollBottom( VclPtr<ScrollAdaptor>::Create( pFrameWin, false ) ),
184 aHScrollLeft( VclPtr<ScrollAdaptor>::Create( pFrameWin, true ) ),
185 aHScrollRight( VclPtr<ScrollAdaptor>::Create( pFrameWin, true ) ),
186 aCornerButton( VclPtr<ScCornerButton>::Create( pFrameWin, &aViewData ) ),
187 aTopButton( VclPtr<ScCornerButton>::Create( pFrameWin, &aViewData ) ),
188 aScrollTimer("ScTabView aScrollTimer"),
189 pTimerWindow( nullptr ),
190 aExtraEditViewManager( pViewShell, pGridWin ),
191 nTipVisible( nullptr ),
192 nTipAlign( QuickHelpFlags::NONE ),
193 nPrevDragPos( 0 ),
194 meBlockMode(None),
195 meHighlightBlockMode(None),
196 nBlockStartX( 0 ),
197 nBlockStartXOrig( 0 ),
198 nBlockEndX( 0 ),
199 nBlockStartY( 0 ),
200 nBlockStartYOrig( 0 ),
201 nBlockEndY( 0 ),
202 nBlockStartZ( 0 ),
203 nBlockEndZ( 0 ),
204 nOldCurX( 0 ),
205 nOldCurY( 0 ),
206 mfPendingTabBarWidth( -1.0 ),
207 mnLOKStartHeaderRow( -2 ),
208 mnLOKEndHeaderRow( -1 ),
209 mnLOKStartHeaderCol( -2 ),
210 mnLOKEndHeaderCol( -1 ),
211 bMinimized( false ),
212 bInUpdateHeader( false ),
213 bInActivatePart( false ),
214 bInZoomUpdate( false ),
215 bMoveIsShift( false ),
216 bDrawSelMode( false ),
217 bLockPaintBrush( false ),
218 bDragging( false ),
219 bBlockNeg( false ),
220 bBlockCols( false ),
221 bBlockRows( false ),
222 mbInlineWithScrollbar( false )
223 {
224 // copy settings of existing shell for this document
225 if (ScTabViewShell* pExistingViewShell = rDocSh.GetBestViewShell())
226 {
227 aViewRenderingData = pExistingViewShell->GetViewRenderingData();
228 EnableAutoSpell(pExistingViewShell->IsAutoSpell());
229 }
230 Init();
231 }
232
233 void ScTabView::InitScrollBar(ScrollAdaptor& rScrollBar, tools::Long nMaxVal, const Link<weld::Scrollbar&, void>& rLink)
234 {
235 rScrollBar.SetRange( Range( 0, nMaxVal ) );
236 rScrollBar.SetLineSize( 1 );
237 rScrollBar.SetPageSize( 1 ); // is queried separately
238 rScrollBar.SetVisibleSize( 10 ); // is reset by Resize
239
240 rScrollBar.SetScrollHdl(rLink);
241 rScrollBar.SetMouseReleaseHdl(LINK(this, ScTabView, EndScrollHdl));
242
243 rScrollBar.EnableRTL( aViewData.GetDocument().IsLayoutRTL( aViewData.GetTabNo() ) );
244
245 // Related: tdf#155266 Eliminate delayed scrollbar redrawing when swiping
246 // By default, the layout idle timer in the InterimWindowItem class
247 // is set to TaskPriority::RESIZE. That is too high of a priority as
248 // it appears that other timers are drawing after the scrollbar has been
249 // redrawn.
250 // As a result, when swiping, the content moves fluidly but the scrollbar
251 // thumb does not move until after swiping stops or pauses. Then, after a
252 // short lag, the scrollbar thumb finally "jumps" to the expected
253 // position.
254 // So, to fix this scrollbar "stickiness" when swiping, setting the
255 // priority to TaskPriority::POST_PAINT causes the scrollbar to be
256 // redrawn after any competing timers.
257 rScrollBar.SetPriority(TaskPriority::POST_PAINT);
258 }
259
260 // Scroll-Timer
261 void ScTabView::SetTimer( ScGridWindow* pWin, const MouseEvent& rMEvt )
262 {
263 pTimerWindow = pWin;
264 aTimerMEvt = rMEvt;
265 aScrollTimer.Start();
266 }
267
268 void ScTabView::ResetTimer()
269 {
270 aScrollTimer.Stop();
271 pTimerWindow = nullptr;
272 }
273
274 IMPL_LINK_NOARG(ScTabView, TimerHdl, Timer *, void)
275 {
276 if (pTimerWindow)
277 pTimerWindow->MouseMove( aTimerMEvt );
278 }
279
280 // --- Resize ---------------------------------------------------------------------
281
282 static void lcl_SetPosSize( vcl::Window& rWindow, const Point& rPos, const Size& rSize,
283 tools::Long nTotalWidth, bool bLayoutRTL )
284 {
285 Point aNewPos = rPos;
286 if ( bLayoutRTL )
287 {
288 aNewPos.setX( nTotalWidth - rPos.X() - rSize.Width() );
289 if ( aNewPos == rWindow.GetPosPixel() && rSize.Width() != rWindow.GetSizePixel().Width() )
290 {
291 // Document windows are manually painted right-to-left, so they need to
292 // be repainted if the size changes.
293 rWindow.Invalidate();
294 }
295 }
296 rWindow.SetPosSizePixel( aNewPos, rSize );
297 }
298
299 void ScTabView::DoResize( const Point& rOffset, const Size& rSize, bool bInner )
300 {
301 HideListBox();
302
303 bool bHasHint = HasHintWindow();
304 if (bHasHint)
305 RemoveHintWindow();
306
307 bool bLayoutRTL = aViewData.GetDocument().IsLayoutRTL( aViewData.GetTabNo() );
308 tools::Long nTotalWidth = rSize.Width();
309 if ( bLayoutRTL )
310 nTotalWidth += 2*rOffset.X();
311
312 bool bVScroll = aViewData.IsVScrollMode();
313 bool bHScroll = aViewData.IsHScrollMode();
314 bool bTabControl = aViewData.IsTabMode();
315 bool bHeaders = aViewData.IsHeaderMode();
316 bool bOutlMode = aViewData.IsOutlineMode();
317 bool bHOutline = bOutlMode && lcl_HasColOutline(aViewData);
318 bool bVOutline = bOutlMode && lcl_HasRowOutline(aViewData);
319
320 if ( aViewData.GetDocShell()->IsPreview() )
321 bHScroll = bVScroll = bTabControl = bHeaders = bHOutline = bVOutline = false;
322
323 tools::Long nBarX = 0;
324 tools::Long nBarY = 0;
325 tools::Long nOutlineX = 0;
326 tools::Long nOutlineY = 0;
327 tools::Long nOutPosX;
328 tools::Long nOutPosY;
329
330 tools::Long nPosX = rOffset.X();
331 tools::Long nPosY = rOffset.Y();
332 tools::Long nSizeX = rSize.Width();
333 tools::Long nSizeY = rSize.Height();
334
335 bMinimized = ( nSizeX<=SC_ICONSIZE || nSizeY<=SC_ICONSIZE );
336 if ( bMinimized )
337 return;
338
339 float fScaleFactor = pFrameWin->GetDPIScaleFactor();
340
341 tools::Long nSplitSizeX = SPLIT_HANDLE_SIZE * fScaleFactor;
342 if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
343 nSplitSizeX = 1;
344 tools::Long nSplitSizeY = SPLIT_HANDLE_SIZE * fScaleFactor;
345 if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX )
346 nSplitSizeY = 1;
347
348 aBorderPos = rOffset;
349 aFrameSize = rSize;
350
351 const StyleSettings& rStyleSettings = pFrameWin->GetSettings().GetStyleSettings();
352
353
354 Size aFontSize = rStyleSettings.GetTabFont().GetFontSize();
355 MapMode aPtMapMode(MapUnit::MapPoint);
356 aFontSize = pFrameWin->LogicToPixel(aFontSize, aPtMapMode);
357 sal_Int32 nTabHeight = aFontSize.Height() + TAB_HEIGHT_MARGIN;
358
359 if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE )
360 {
361 if ( aViewData.GetHSplitPos() > nSizeX - SPLIT_MARGIN )
362 {
363 aViewData.SetHSplitMode( SC_SPLIT_NONE );
364 if ( WhichH( aViewData.GetActivePart() ) == SC_SPLIT_RIGHT )
365 ActivatePart( SC_SPLIT_BOTTOMLEFT );
366 InvalidateSplit();
367 }
368 }
369 if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
370 {
371 if ( aViewData.GetVSplitPos() > nSizeY - SPLIT_MARGIN )
372 {
373 aViewData.SetVSplitMode( SC_SPLIT_NONE );
374 if ( WhichV( aViewData.GetActivePart() ) == SC_SPLIT_TOP )
375 ActivatePart( SC_SPLIT_BOTTOMLEFT );
376 InvalidateSplit();
377 }
378 }
379
380 UpdateShow();
381
382 if (bHScroll || bVScroll) // Scrollbars horizontal or vertical
383 {
384 tools::Long nScrollBarSize = rStyleSettings.GetScrollBarSize();
385 if (bVScroll)
386 {
387 nBarX = nScrollBarSize;
388 nSizeX -= nBarX;
389 }
390 if (bHScroll)
391 {
392 nBarY = nTabHeight;
393
394 if (!mbInlineWithScrollbar)
395 nBarY += nScrollBarSize;
396
397 nSizeY -= nBarY;
398
399 tools::Long nSizeLt = 0; // left scroll bar
400 tools::Long nSizeRt = 0; // right scroll bar
401 tools::Long nSizeSp = 0; // splitter
402
403 switch (aViewData.GetHSplitMode())
404 {
405 case SC_SPLIT_NONE:
406 nSizeSp = nSplitSizeX;
407 nSizeLt = nSizeX - nSizeSp; // Convert the corner
408 break;
409 case SC_SPLIT_NORMAL:
410 nSizeSp = nSplitSizeX;
411 nSizeLt = aViewData.GetHSplitPos();
412 break;
413 case SC_SPLIT_FIX:
414 nSizeSp = 0;
415 nSizeLt = 0;
416 break;
417 }
418 nSizeRt = nSizeX - nSizeLt - nSizeSp;
419
420 tools::Long nTabSize = 0;
421
422 if (bTabControl)
423 {
424 // pending relative tab bar width from extended document options
425 if( mfPendingTabBarWidth >= 0.0 )
426 {
427 SetRelTabBarWidth( mfPendingTabBarWidth );
428 mfPendingTabBarWidth = -1.0;
429 }
430
431 if (mbInlineWithScrollbar)
432 {
433 nTabSize = pTabControl->GetSizePixel().Width();
434
435 if ( aViewData.GetHSplitMode() != SC_SPLIT_FIX ) // left Scrollbar
436 {
437 if (nTabSize > nSizeLt-SC_SCROLLBAR_MIN)
438 nTabSize = nSizeLt-SC_SCROLLBAR_MIN;
439 if (nTabSize < SC_TABBAR_MIN)
440 nTabSize = SC_TABBAR_MIN;
441 nSizeLt -= nTabSize;
442 }
443 else // right Scrollbar
444 {
445 if (nTabSize > nSizeRt-SC_SCROLLBAR_MIN)
446 nTabSize = nSizeRt-SC_SCROLLBAR_MIN;
447 if (nTabSize < SC_TABBAR_MIN)
448 nTabSize = SC_TABBAR_MIN;
449 nSizeRt -= nTabSize;
450 }
451 }
452 }
453
454 if (mbInlineWithScrollbar)
455 {
456 Point aTabPoint(nPosX, nPosY + nSizeY);
457 Size aTabSize(nTabSize, nBarY);
458 lcl_SetPosSize(*pTabControl, aTabPoint, aTabSize, nTotalWidth, bLayoutRTL);
459 pTabControl->SetSheetLayoutRTL(bLayoutRTL);
460
461 Point aHScrollLeftPoint(nPosX + nTabSize, nPosY + nSizeY);
462 Size aHScrollLeftSize(nSizeLt, nBarY);
463 lcl_SetPosSize(*aHScrollLeft, aHScrollLeftPoint, aHScrollLeftSize, nTotalWidth, bLayoutRTL);
464
465 Point aHSplitterPoint(nPosX + nTabSize + nSizeLt, nPosY + nSizeY);
466 Size aHSplitterSize(nSizeSp, nBarY);
467 lcl_SetPosSize(*pHSplitter, aHSplitterPoint, aHSplitterSize, nTotalWidth, bLayoutRTL);
468
469 Point aHScrollRightPoint(nPosX + nTabSize + nSizeLt + nSizeSp, nPosY + nSizeY);
470 Size aHScrollRightSize(nSizeRt, nBarY);
471 lcl_SetPosSize(*aHScrollRight, aHScrollRightPoint, aHScrollRightSize, nTotalWidth, bLayoutRTL);
472 }
473 else
474 {
475 Point aTabPoint(nPosX, nPosY + nSizeY + nScrollBarSize);
476 Size aTabSize(nSizeX, nTabHeight);
477 lcl_SetPosSize(*pTabControl, aTabPoint, aTabSize, nTotalWidth, bLayoutRTL);
478 pTabControl->SetSheetLayoutRTL(bLayoutRTL);
479
480 Point aHScrollLeftPoint(nPosX, nPosY + nSizeY);
481 Size aHScrollLeftSize(nSizeLt, nScrollBarSize);
482 lcl_SetPosSize(*aHScrollLeft, aHScrollLeftPoint, aHScrollLeftSize, nTotalWidth, bLayoutRTL);
483
484 Point aHSplitterPoint(nPosX + nSizeLt, nPosY + nSizeY);
485 Size aHSplitterSize(nSizeSp, nScrollBarSize);
486 lcl_SetPosSize(*pHSplitter, aHSplitterPoint, aHSplitterSize, nTotalWidth, bLayoutRTL);
487
488 Point aHScrollRightPoint(nPosX + nSizeLt + nSizeSp, nPosY + nSizeY);
489 Size aHScrollRightSize(nSizeRt, nScrollBarSize);
490 lcl_SetPosSize(*aHScrollRight, aHScrollRightPoint, aHScrollRightSize, nTotalWidth, bLayoutRTL);
491 }
492 // SetDragRectPixel is done below
493 }
494
495 if (bVScroll)
496 {
497 tools::Long nSizeUp = 0; // upper scroll bar
498 tools::Long nSizeSp = 0; // splitter
499 tools::Long nSizeDn; // lower scroll bar
500
501 switch (aViewData.GetVSplitMode())
502 {
503 case SC_SPLIT_NONE:
504 nSizeUp = 0;
505 nSizeSp = nSplitSizeY;
506 break;
507 case SC_SPLIT_NORMAL:
508 nSizeUp = aViewData.GetVSplitPos();
509 nSizeSp = nSplitSizeY;
510 break;
511 case SC_SPLIT_FIX:
512 nSizeUp = 0;
513 nSizeSp = 0;
514 break;
515 }
516 nSizeDn = nSizeY - nSizeUp - nSizeSp;
517
518 lcl_SetPosSize( *aVScrollTop, Point(nPosX + nSizeX, nPosY),
519 Size(nBarX, nSizeUp), nTotalWidth, bLayoutRTL );
520 lcl_SetPosSize( *pVSplitter, Point( nPosX + nSizeX, nPosY+nSizeUp ),
521 Size( nBarX, nSizeSp ), nTotalWidth, bLayoutRTL );
522 lcl_SetPosSize( *aVScrollBottom, Point(nPosX + nSizeX,
523 nPosY + nSizeUp + nSizeSp),
524 Size(nBarX, nSizeDn), nTotalWidth, bLayoutRTL );
525
526 // SetDragRectPixel is done below
527 }
528 }
529
530 // SetDragRectPixel also without Scrollbars etc., when already split
531 if ( bHScroll || aViewData.GetHSplitMode() != SC_SPLIT_NONE )
532 pHSplitter->SetDragRectPixel(
533 tools::Rectangle( nPosX, nPosY, nPosX+nSizeX, nPosY+nSizeY ), pFrameWin );
534 if ( bVScroll || aViewData.GetVSplitMode() != SC_SPLIT_NONE )
535 pVSplitter->SetDragRectPixel(
536 tools::Rectangle( nPosX, nPosY, nPosX+nSizeX, nPosY+nSizeY ), pFrameWin );
537
538 if (bTabControl && ! bHScroll )
539 {
540 nBarY = aHScrollLeft->GetSizePixel().Height();
541
542 tools::Long nSize1 = nSizeX;
543
544 tools::Long nTabSize = nSize1;
545 if (nTabSize < 0) nTabSize = 0;
546
547 lcl_SetPosSize( *pTabControl, Point(nPosX, nPosY+nSizeY-nBarY),
548 Size(nTabSize, nBarY), nTotalWidth, bLayoutRTL );
549 nSizeY -= nBarY;
550
551 if( bVScroll )
552 {
553 Size aVScrSize = aVScrollBottom->GetSizePixel();
554 aVScrSize.AdjustHeight( -nBarY );
555 aVScrollBottom->SetSizePixel( aVScrSize );
556 }
557 }
558
559 nOutPosX = nPosX;
560 nOutPosY = nPosY;
561
562 // Outline-Controls
563 if (bVOutline && pRowOutline[SC_SPLIT_BOTTOM])
564 {
565 nOutlineX = pRowOutline[SC_SPLIT_BOTTOM]->GetDepthSize();
566 nSizeX -= nOutlineX;
567 nPosX += nOutlineX;
568 }
569 if (bHOutline && pColOutline[SC_SPLIT_LEFT])
570 {
571 nOutlineY = pColOutline[SC_SPLIT_LEFT]->GetDepthSize();
572 nSizeY -= nOutlineY;
573 nPosY += nOutlineY;
574 }
575
576 if (bHeaders) // column/row header
577 {
578 nBarX = pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width();
579 nBarY = pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height();
580 nSizeX -= nBarX;
581 nSizeY -= nBarY;
582 nPosX += nBarX;
583 nPosY += nBarY;
584 }
585 else
586 nBarX = nBarY = 0;
587
588 // evaluate splitter
589
590 tools::Long nLeftSize = nSizeX;
591 tools::Long nRightSize = 0;
592 tools::Long nTopSize = 0;
593 tools::Long nBottomSize = nSizeY;
594 tools::Long nSplitPosX = nPosX;
595 tools::Long nSplitPosY = nPosY;
596
597 if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE )
598 {
599 tools::Long nSplitHeight = rSize.Height();
600 if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
601 {
602 // Do not allow freeze splitter to overlap scroll bar/tab bar
603 if ( bHScroll )
604 nSplitHeight -= aHScrollLeft->GetSizePixel().Height();
605 else if ( bTabControl && pTabControl )
606 nSplitHeight -= pTabControl->GetSizePixel().Height();
607 }
608 nSplitPosX = aViewData.GetHSplitPos();
609 lcl_SetPosSize( *pHSplitter,
610 Point(nSplitPosX, nOutPosY),
611 Size(nSplitSizeX, nSplitHeight - nTabHeight), nTotalWidth, bLayoutRTL);
612 nLeftSize = nSplitPosX - nPosX;
613 nSplitPosX += nSplitSizeX;
614 nRightSize = nSizeX - nLeftSize - nSplitSizeX;
615 }
616 if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
617 {
618 tools::Long nSplitWidth = rSize.Width();
619 if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX && bVScroll )
620 nSplitWidth -= aVScrollBottom->GetSizePixel().Width();
621 nSplitPosY = aViewData.GetVSplitPos();
622 lcl_SetPosSize( *pVSplitter,
623 Point( nOutPosX, nSplitPosY ), Size( nSplitWidth, nSplitSizeY ), nTotalWidth, bLayoutRTL );
624 nTopSize = nSplitPosY - nPosY;
625 nSplitPosY += nSplitSizeY;
626 nBottomSize = nSizeY - nTopSize - nSplitSizeY;
627 }
628
629 // ShowHide for pColOutline / pRowOutline happens in UpdateShow
630
631 if (bHOutline) // Outline-Controls
632 {
633 if (pColOutline[SC_SPLIT_LEFT])
634 {
635 pColOutline[SC_SPLIT_LEFT]->SetHeaderSize( nBarX );
636 lcl_SetPosSize( *pColOutline[SC_SPLIT_LEFT],
637 Point(nPosX-nBarX,nOutPosY), Size(nLeftSize+nBarX,nOutlineY), nTotalWidth, bLayoutRTL );
638 }
639 if (pColOutline[SC_SPLIT_RIGHT])
640 {
641 pColOutline[SC_SPLIT_RIGHT]->SetHeaderSize( 0 ); // always call to update RTL flag
642 lcl_SetPosSize( *pColOutline[SC_SPLIT_RIGHT],
643 Point(nSplitPosX,nOutPosY), Size(nRightSize,nOutlineY), nTotalWidth, bLayoutRTL );
644 }
645 }
646 if (bVOutline)
647 {
648 if (nTopSize)
649 {
650 if (pRowOutline[SC_SPLIT_TOP] && pRowOutline[SC_SPLIT_BOTTOM])
651 {
652 pRowOutline[SC_SPLIT_TOP]->SetHeaderSize( nBarY );
653 lcl_SetPosSize( *pRowOutline[SC_SPLIT_TOP],
654 Point(nOutPosX,nPosY-nBarY), Size(nOutlineX,nTopSize+nBarY), nTotalWidth, bLayoutRTL );
655 pRowOutline[SC_SPLIT_BOTTOM]->SetHeaderSize( 0 );
656 lcl_SetPosSize( *pRowOutline[SC_SPLIT_BOTTOM],
657 Point(nOutPosX,nSplitPosY), Size(nOutlineX,nBottomSize), nTotalWidth, bLayoutRTL );
658 }
659 }
660 else if (pRowOutline[SC_SPLIT_BOTTOM])
661 {
662 pRowOutline[SC_SPLIT_BOTTOM]->SetHeaderSize( nBarY );
663 lcl_SetPosSize( *pRowOutline[SC_SPLIT_BOTTOM],
664 Point(nOutPosX,nSplitPosY-nBarY), Size(nOutlineX,nBottomSize+nBarY), nTotalWidth, bLayoutRTL );
665 }
666 }
667 if (bHOutline && bVOutline)
668 {
669 lcl_SetPosSize( *aTopButton, Point(nOutPosX,nOutPosY), Size(nOutlineX,nOutlineY), nTotalWidth, bLayoutRTL );
670 aTopButton->Show();
671 }
672 else
673 aTopButton->Hide();
674
675 if (bHeaders) // column/row header
676 {
677 lcl_SetPosSize( *pColBar[SC_SPLIT_LEFT],
678 Point(nPosX,nPosY-nBarY), Size(nLeftSize,nBarY), nTotalWidth, bLayoutRTL );
679 if (pColBar[SC_SPLIT_RIGHT])
680 lcl_SetPosSize( *pColBar[SC_SPLIT_RIGHT],
681 Point(nSplitPosX,nPosY-nBarY), Size(nRightSize,nBarY), nTotalWidth, bLayoutRTL );
682
683 if (pRowBar[SC_SPLIT_TOP])
684 lcl_SetPosSize( *pRowBar[SC_SPLIT_TOP],
685 Point(nPosX-nBarX,nPosY), Size(nBarX,nTopSize), nTotalWidth, bLayoutRTL );
686 lcl_SetPosSize( *pRowBar[SC_SPLIT_BOTTOM],
687 Point(nPosX-nBarX,nSplitPosY), Size(nBarX,nBottomSize), nTotalWidth, bLayoutRTL );
688
689 lcl_SetPosSize( *aCornerButton, Point(nPosX-nBarX,nPosY-nBarY), Size(nBarX,nBarY), nTotalWidth, bLayoutRTL );
690 aCornerButton->Show();
691 pColBar[SC_SPLIT_LEFT]->Show();
692 pRowBar[SC_SPLIT_BOTTOM]->Show();
693 }
694 else
695 {
696 aCornerButton->Hide();
697 pColBar[SC_SPLIT_LEFT]->Hide(); // always here
698 pRowBar[SC_SPLIT_BOTTOM]->Hide();
699 }
700
701 // Grid-Windows
702
703 if (bInner)
704 {
705 tools::Long nInnerPosX = bLayoutRTL ? ( nTotalWidth - nPosX - nLeftSize ) : nPosX;
706 pGridWin[SC_SPLIT_BOTTOMLEFT]->SetPosPixel( Point(nInnerPosX,nSplitPosY) );
707 }
708 else
709 {
710 lcl_SetPosSize( *pGridWin[SC_SPLIT_BOTTOMLEFT],
711 Point(nPosX,nSplitPosY), Size(nLeftSize,nBottomSize), nTotalWidth, bLayoutRTL );
712 if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE )
713 lcl_SetPosSize( *pGridWin[SC_SPLIT_BOTTOMRIGHT],
714 Point(nSplitPosX,nSplitPosY), Size(nRightSize,nBottomSize), nTotalWidth, bLayoutRTL );
715 if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
716 lcl_SetPosSize( *pGridWin[SC_SPLIT_TOPLEFT],
717 Point(nPosX,nPosY), Size(nLeftSize,nTopSize), nTotalWidth, bLayoutRTL );
718 if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE && aViewData.GetVSplitMode() != SC_SPLIT_NONE )
719 lcl_SetPosSize( *pGridWin[SC_SPLIT_TOPRIGHT],
720 Point(nSplitPosX,nPosY), Size(nRightSize,nTopSize), nTotalWidth, bLayoutRTL );
721 }
722
723 // update scroll bars
724
725 if (!bInUpdateHeader)
726 {
727 UpdateScrollBars(); // don't reset scroll bars when scrolling
728 UpdateHeaderWidth();
729
730 InterpretVisible(); // have everything calculated before painting
731 }
732
733 if (bHasHint)
734 TestHintWindow(); // reposition
735
736 UpdateVarZoom(); // update variable zoom types (after resizing GridWindows)
737
738 if (aViewData.GetViewShell()->HasAccessibilityObjects())
739 aViewData.GetViewShell()->BroadcastAccessibility(SfxHint(SfxHintId::ScAccWindowResized));
740 }
741
742 void ScTabView::UpdateVarZoom()
743 {
744 // update variable zoom types
745
746 SvxZoomType eZoomType = GetZoomType();
747 if (eZoomType == SvxZoomType::PERCENT || bInZoomUpdate)
748 return;
749
750 bInZoomUpdate = true;
751 const Fraction& rOldX = GetViewData().GetZoomX();
752 const Fraction& rOldY = GetViewData().GetZoomY();
753 tools::Long nOldPercent = tools::Long(rOldY * 100);
754 sal_uInt16 nNewZoom = CalcZoom( eZoomType, static_cast<sal_uInt16>(nOldPercent) );
755 Fraction aNew( nNewZoom, 100 );
756
757 if ( aNew != rOldX || aNew != rOldY )
758 {
759 SetZoom( aNew, aNew, false ); // always separately per sheet
760 PaintGrid();
761 PaintTop();
762 PaintLeft();
763 aViewData.GetViewShell()->GetViewFrame().GetBindings().Invalidate( SID_ATTR_ZOOM );
764 aViewData.GetViewShell()->GetViewFrame().GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
765 aViewData.GetBindings().Invalidate(SID_ZOOM_IN);
766 aViewData.GetBindings().Invalidate(SID_ZOOM_OUT);
767 }
768 bInZoomUpdate = false;
769 }
770
771 void ScTabView::UpdateFixPos()
772 {
773 bool bResize = false;
774 if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
775 if (aViewData.UpdateFixX())
776 bResize = true;
777 if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX )
778 if (aViewData.UpdateFixY())
779 bResize = true;
780 if (bResize)
781 RepeatResize(false);
782 }
783
784 void ScTabView::RepeatResize( bool bUpdateFix )
785 {
786 if ( bUpdateFix )
787 {
788 ScSplitMode eHSplit = aViewData.GetHSplitMode();
789 ScSplitMode eVSplit = aViewData.GetVSplitMode();
790
791 // #i46796# UpdateFixX / UpdateFixY uses GetGridOffset, which requires the
792 // outline windows to be available. So UpdateShow has to be called before
793 // (also called from DoResize).
794 if ( eHSplit == SC_SPLIT_FIX || eVSplit == SC_SPLIT_FIX )
795 UpdateShow();
796
797 if ( eHSplit == SC_SPLIT_FIX )
798 aViewData.UpdateFixX();
799 if ( eVSplit == SC_SPLIT_FIX )
800 aViewData.UpdateFixY();
801 }
802
803 DoResize( aBorderPos, aFrameSize );
804
805 //! border must be reset ???
806 }
807
808 void ScTabView::GetBorderSize( SvBorder& rBorder, const Size& /* rSize */ )
809 {
810 bool bScrollBars = aViewData.IsVScrollMode();
811 bool bHeaders = aViewData.IsHeaderMode();
812 bool bOutlMode = aViewData.IsOutlineMode();
813 bool bHOutline = bOutlMode && lcl_HasColOutline(aViewData);
814 bool bVOutline = bOutlMode && lcl_HasRowOutline(aViewData);
815 bool bLayoutRTL = aViewData.GetDocument().IsLayoutRTL( aViewData.GetTabNo() );
816
817 rBorder = SvBorder();
818
819 if (bScrollBars) // Scrollbars horizontal or vertical
820 {
821 rBorder.Right() += aVScrollBottom->GetSizePixel().Width();
822 rBorder.Bottom() += aHScrollLeft->GetSizePixel().Height();
823 }
824
825 // Outline-Controls
826 if (bVOutline && pRowOutline[SC_SPLIT_BOTTOM])
827 rBorder.Left() += pRowOutline[SC_SPLIT_BOTTOM]->GetDepthSize();
828 if (bHOutline && pColOutline[SC_SPLIT_LEFT])
829 rBorder.Top() += pColOutline[SC_SPLIT_LEFT]->GetDepthSize();
830
831 if (bHeaders) // column/row headers
832 {
833 rBorder.Left() += pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width();
834 rBorder.Top() += pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height();
835 }
836
837 if ( bLayoutRTL )
838 ::std::swap( rBorder.Left(), rBorder.Right() );
839 }
840
841 IMPL_LINK_NOARG(ScTabView, TabBarResize, TabBar*, void)
842 {
843 if (!aViewData.IsHScrollMode())
844 return;
845
846 tools::Long nSize = pTabControl->GetSplitSize();
847
848 if (aViewData.GetHSplitMode() != SC_SPLIT_FIX)
849 {
850 tools::Long nMax = pHSplitter->GetPosPixel().X();
851 if( pTabControl->IsEffectiveRTL() )
852 nMax = pFrameWin->GetSizePixel().Width() - nMax;
853 --nMax;
854 if (nSize>nMax) nSize = nMax;
855 }
856
857 if ( nSize != pTabControl->GetSizePixel().Width() )
858 {
859 pTabControl->SetSizePixel( Size( nSize,
860 pTabControl->GetSizePixel().Height() ) );
861 RepeatResize();
862 }
863 }
864
865 void ScTabView::SetTabBarWidth( tools::Long nNewWidth )
866 {
867 Size aSize = pTabControl->GetSizePixel();
868
869 if ( aSize.Width() != nNewWidth )
870 {
871 aSize.setWidth( nNewWidth );
872 pTabControl->SetSizePixel( aSize );
873 }
874 }
875
876 void ScTabView::SetRelTabBarWidth( double fRelTabBarWidth )
877 {
878 if( (0.0 <= fRelTabBarWidth) && (fRelTabBarWidth <= 1.0) )
879 if( tools::Long nFrameWidth = pFrameWin->GetSizePixel().Width() )
880 SetTabBarWidth( static_cast< tools::Long >( fRelTabBarWidth * nFrameWidth + 0.5 ) );
881 }
882
883 void ScTabView::SetPendingRelTabBarWidth( double fRelTabBarWidth )
884 {
885 mfPendingTabBarWidth = fRelTabBarWidth;
886 SetRelTabBarWidth( fRelTabBarWidth );
887 }
888
889 tools::Long ScTabView::GetTabBarWidth() const
890 {
891 return pTabControl->GetSizePixel().Width();
892 }
893
894 double ScTabView::GetRelTabBarWidth()
895 {
896 return 0.5;
897 }
898
899 ScGridWindow* ScTabView::GetActiveWin()
900 {
901 ScSplitPos ePos = aViewData.GetActivePart();
902 OSL_ENSURE(pGridWin[ePos],"no active window");
903 return pGridWin[ePos];
904 }
905
906 void ScTabView::SetActivePointer( PointerStyle nPointer )
907 {
908 for (VclPtr<ScGridWindow> & pWin : pGridWin)
909 if (pWin)
910 pWin->SetPointer( nPointer );
911 }
912
913 void ScTabView::ActiveGrabFocus()
914 {
915 ScSplitPos ePos = aViewData.GetActivePart();
916 if (pGridWin[ePos])
917 pGridWin[ePos]->GrabFocus();
918 }
919
920 ScSplitPos ScTabView::FindWindow( const vcl::Window* pWindow ) const
921 {
922 ScSplitPos eVal = SC_SPLIT_BOTTOMLEFT; // Default
923 for (sal_uInt16 i=0; i<4; i++)
924 if ( pGridWin[i] == pWindow )
925 eVal = static_cast<ScSplitPos>(i);
926
927 return eVal;
928 }
929
930 Point ScTabView::GetGridOffset() const
931 {
932 Point aPos;
933
934 // size as in DoResize
935
936 bool bHeaders = aViewData.IsHeaderMode();
937 bool bOutlMode = aViewData.IsOutlineMode();
938 bool bHOutline = bOutlMode && lcl_HasColOutline(aViewData);
939 bool bVOutline = bOutlMode && lcl_HasRowOutline(aViewData);
940
941 // Outline-Controls
942 if (bVOutline && pRowOutline[SC_SPLIT_BOTTOM])
943 aPos.AdjustX(pRowOutline[SC_SPLIT_BOTTOM]->GetDepthSize() );
944 if (bHOutline && pColOutline[SC_SPLIT_LEFT])
945 aPos.AdjustY(pColOutline[SC_SPLIT_LEFT]->GetDepthSize() );
946
947 if (bHeaders) // column/row headers
948 {
949 if (pRowBar[SC_SPLIT_BOTTOM])
950 aPos.AdjustX(pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width() );
951 if (pColBar[SC_SPLIT_LEFT])
952 aPos.AdjustY(pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height() );
953 }
954
955 return aPos;
956 }
957
958 // --- Scroll-Bars --------------------------------------------------------
959
960 void ScTabView::SetZoomPercentFromCommand(sal_uInt16 nZoomPercent)
961 {
962 // scroll wheel doesn't set the AppOptions default
963
964 bool bSyncZoom = ScModule::get()->GetAppOptions().GetSynchronizeZoom();
965 SetZoomType(SvxZoomType::PERCENT, bSyncZoom);
966 Fraction aFract(nZoomPercent, 100);
967 SetZoom(aFract, aFract, bSyncZoom);
968 PaintGrid();
969 PaintTop();
970 PaintLeft();
971 aViewData.GetBindings().Invalidate( SID_ATTR_ZOOM);
972 aViewData.GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER);
973 aViewData.GetBindings().Invalidate( SID_ZOOM_IN);
974 aViewData.GetBindings().Invalidate( SID_ZOOM_OUT);
975 }
976
977 bool ScTabView::ScrollCommand( const CommandEvent& rCEvt, ScSplitPos ePos )
978 {
979 HideNoteMarker();
980
981 bool bDone = false;
982 const CommandWheelData* pData = rCEvt.GetWheelData();
983 if (pData && pData->GetMode() == CommandWheelMode::ZOOM)
984 {
985 if ( !aViewData.GetViewShell()->GetViewFrame().GetFrame().IsInPlace() )
986 {
987 // for ole inplace editing, the scale is defined by the visarea and client size
988 // and can't be changed directly
989
990 const Fraction& rOldY = aViewData.GetZoomY();
991 sal_uInt16 nOld = static_cast<tools::Long>( rOldY * 100 );
992 sal_uInt16 nNew;
993 if ( pData->GetDelta() < 0 )
994 nNew = std::max( MINZOOM, basegfx::zoomtools::zoomOut( nOld ));
995 else
996 nNew = std::min( MAXZOOM, basegfx::zoomtools::zoomIn( nOld ));
997 if ( nNew != nOld )
998 {
999 SetZoomPercentFromCommand(nNew);
1000 }
1001
1002 bDone = true;
1003 }
1004 }
1005 else
1006 {
1007 ScHSplitPos eHPos = WhichH(ePos);
1008 ScVSplitPos eVPos = WhichV(ePos);
1009 ScrollAdaptor* pHScroll = ( eHPos == SC_SPLIT_LEFT ) ? aHScrollLeft.get() : aHScrollRight.get();
1010 ScrollAdaptor* pVScroll = ( eVPos == SC_SPLIT_TOP ) ? aVScrollTop.get() : aVScrollBottom.get();
1011 if ( pGridWin[ePos] )
1012 bDone = pGridWin[ePos]->HandleScrollCommand( rCEvt, pHScroll, pVScroll );
1013 }
1014 return bDone;
1015 }
1016
1017 bool ScTabView::GesturePanCommand(const CommandEvent& rCEvt)
1018 {
1019 HideNoteMarker();
1020
1021 bool bDone = false;
1022 const CommandGesturePanData* pData = rCEvt.GetGesturePanData();
1023 if (!pData)
1024 return false;
1025
1026 if (aViewData.GetViewShell()->GetViewFrame().GetFrame().IsInPlace())
1027 return false;
1028
1029 ScSplitPos ePos = aViewData.GetActivePart();
1030 ScHSplitPos eHPos = WhichH(ePos);
1031 ScVSplitPos eVPos = WhichV(ePos);
1032 ScrollAdaptor* pHScroll = (eHPos == SC_SPLIT_LEFT) ? aHScrollLeft.get() : aHScrollRight.get();
1033 ScrollAdaptor* pVScroll = (eVPos == SC_SPLIT_TOP) ? aVScrollTop.get() : aVScrollBottom.get();
1034 if (pGridWin[ePos])
1035 bDone = pGridWin[ePos]->HandleScrollCommand(rCEvt, pHScroll, pVScroll);
1036
1037 return bDone;
1038 }
1039
1040 bool ScTabView::GestureZoomCommand(const CommandEvent& rCEvt)
1041 {
1042 HideNoteMarker();
1043
1044 const CommandGestureZoomData* pData = rCEvt.GetGestureZoomData();
1045 if (!pData)
1046 return false;
1047
1048 if (aViewData.GetViewShell()->GetViewFrame().GetFrame().IsInPlace())
1049 return false;
1050
1051 if (pData->meEventType == GestureEventZoomType::Begin)
1052 {
1053 mfLastZoomScale = pData->mfScaleDelta;
1054 return true;
1055 }
1056
1057 if (pData->meEventType == GestureEventZoomType::Update)
1058 {
1059 double deltaBetweenEvents = (pData->mfScaleDelta - mfLastZoomScale) / mfLastZoomScale;
1060 mfLastZoomScale = pData->mfScaleDelta;
1061
1062 // Accumulate fractional zoom to avoid small zoom changes from being ignored
1063 mfAccumulatedZoom += deltaBetweenEvents;
1064 int nZoomChangePercent = mfAccumulatedZoom * 100;
1065 mfAccumulatedZoom -= nZoomChangePercent / 100.0;
1066
1067 const Fraction& rOldY = aViewData.GetZoomY();
1068 sal_uInt16 nOld = static_cast<tools::Long>(rOldY * 100);
1069 sal_uInt16 nNew = nOld + nZoomChangePercent;
1070 nNew = std::clamp<sal_uInt16>(nNew, MINZOOM, MAXZOOM);
1071
1072 if (nNew != nOld)
1073 {
1074 SetZoomPercentFromCommand(nNew);
1075 }
1076
1077 return true;
1078 }
1079 return true;
1080 }
1081
1082 IMPL_LINK_NOARG(ScTabView, HScrollLeftHdl, weld::Scrollbar&, void)
1083 {
1084 ScrollHdl(aHScrollLeft.get());
1085 }
1086
1087 IMPL_LINK_NOARG(ScTabView, HScrollRightHdl, weld::Scrollbar&, void)
1088 {
1089 ScrollHdl(aHScrollRight.get());
1090 }
1091
1092 IMPL_LINK_NOARG(ScTabView, VScrollTopHdl, weld::Scrollbar&, void)
1093 {
1094 ScrollHdl(aVScrollTop.get());
1095 }
1096
1097 IMPL_LINK_NOARG(ScTabView, VScrollBottomHdl, weld::Scrollbar&, void)
1098 {
1099 ScrollHdl(aVScrollBottom.get());
1100 }
1101
1102 IMPL_LINK_NOARG(ScTabView, EndScrollHdl, const MouseEvent&, bool)
1103 {
1104 if (bDragging)
1105 {
1106 UpdateScrollBars();
1107 bDragging = false;
1108 }
1109 return false;
1110 }
1111
1112 void ScTabView::ScrollHdl(ScrollAdaptor* pScroll)
1113 {
1114 bool bUpdateHorizontalScrollbars = false;
1115
1116 bool bHoriz = ( pScroll == aHScrollLeft.get() || pScroll == aHScrollRight.get() );
1117 tools::Long nViewPos;
1118 if ( bHoriz )
1119 nViewPos = aViewData.GetPosX( (pScroll == aHScrollLeft.get()) ?
1120 SC_SPLIT_LEFT : SC_SPLIT_RIGHT );
1121 else
1122 nViewPos = aViewData.GetPosY( (pScroll == aVScrollTop.get()) ?
1123 SC_SPLIT_TOP : SC_SPLIT_BOTTOM );
1124
1125 bool bLayoutRTL = bHoriz && aViewData.GetDocument().IsLayoutRTL( aViewData.GetTabNo() );
1126
1127 ScrollType eType = pScroll->GetScrollType();
1128 if ( eType == ScrollType::Drag )
1129 {
1130 if (!bDragging)
1131 {
1132 bDragging = true;
1133 nPrevDragPos = nViewPos;
1134 }
1135
1136 // show scroll position
1137 // (only QuickHelp, there is no entry for it in the status bar)
1138
1139 if (Help::IsQuickHelpEnabled())
1140 {
1141 Size aSize = pScroll->GetSizePixel();
1142
1143 /* Convert scrollbar mouse position to screen position. If RTL
1144 mode of scrollbar differs from RTL mode of its parent, then the
1145 direct call to Window::OutputToNormalizedScreenPixel() will
1146 give unusable results, because calculation of screen position
1147 is based on parent orientation and expects equal orientation of
1148 the child position. Need to mirror mouse position before. */
1149 Point aMousePos = pScroll->GetPointerPosPixel();
1150 if( pScroll->IsRTLEnabled() != pScroll->GetParent()->IsRTLEnabled() )
1151 aMousePos.setX( aSize.Width() - aMousePos.X() - 1 );
1152 aMousePos = pScroll->OutputToNormalizedScreenPixel( aMousePos );
1153
1154 // convert top-left position of scrollbar to screen position
1155 Point aPos = pScroll->OutputToNormalizedScreenPixel( Point() );
1156
1157 // get scrollbar scroll position for help text (row number/column name)
1158 tools::Long nScrollMin = 0; // simulate RangeMin
1159 if ( aViewData.GetHSplitMode()==SC_SPLIT_FIX && pScroll == aHScrollRight.get() )
1160 nScrollMin = aViewData.GetFixPosX();
1161 if ( aViewData.GetVSplitMode()==SC_SPLIT_FIX && pScroll == aVScrollBottom.get() )
1162 nScrollMin = aViewData.GetFixPosY();
1163 tools::Long nScrollPos = GetScrollBarPos( *pScroll, bLayoutRTL ) + nScrollMin;
1164
1165 OUString aHelpStr;
1166 tools::Rectangle aRect;
1167 QuickHelpFlags nAlign;
1168 if (bHoriz)
1169 {
1170 aHelpStr = ScResId(STR_COLUMN) +
1171 " " + ScColToAlpha(static_cast<SCCOL>(nScrollPos));
1172
1173 aRect.SetLeft( aMousePos.X() );
1174 aRect.SetTop( aPos.Y() - 4 );
1175 nAlign = QuickHelpFlags::Bottom|QuickHelpFlags::Center;
1176 }
1177 else
1178 {
1179 aHelpStr = ScResId(STR_ROW) +
1180 " " + OUString::number(nScrollPos + 1);
1181
1182 // note that bLayoutRTL is always false here, because bLayoutRTL depends on bHoriz
1183
1184 // show quicktext always inside sheet area
1185 aRect.SetLeft(aPos.X() - 8);
1186 aRect.SetTop( aMousePos.Y() );
1187 nAlign = QuickHelpFlags::Right | QuickHelpFlags::VCenter;
1188 }
1189 aRect.SetRight( aRect.Left() );
1190 aRect.SetBottom( aRect.Top() );
1191
1192 Help::ShowQuickHelp(pScroll->GetParent(), aRect, aHelpStr, nAlign);
1193 }
1194 }
1195 else
1196 bDragging = false;
1197
1198 if ( bHoriz && bLayoutRTL )
1199 {
1200 // change scroll type so visible/previous cells calculation below remains the same
1201 switch ( eType )
1202 {
1203 case ScrollType::LineUp: eType = ScrollType::LineDown; break;
1204 case ScrollType::LineDown: eType = ScrollType::LineUp; break;
1205 case ScrollType::PageUp: eType = ScrollType::PageDown; break;
1206 case ScrollType::PageDown: eType = ScrollType::PageUp; break;
1207 default:
1208 {
1209 // added to avoid warnings
1210 }
1211 }
1212 }
1213
1214 tools::Long nDelta(0);
1215 switch ( eType )
1216 {
1217 case ScrollType::LineUp:
1218 nDelta = -1;
1219 break;
1220 case ScrollType::LineDown:
1221 nDelta = 1;
1222 break;
1223 case ScrollType::PageUp:
1224 if ( pScroll == aHScrollLeft.get() ) nDelta = -static_cast<tools::Long>(aViewData.PrevCellsX( SC_SPLIT_LEFT ));
1225 if ( pScroll == aHScrollRight.get() ) nDelta = -static_cast<tools::Long>(aViewData.PrevCellsX( SC_SPLIT_RIGHT ));
1226 if ( pScroll == aVScrollTop.get() ) nDelta = -static_cast<tools::Long>(aViewData.PrevCellsY( SC_SPLIT_TOP ));
1227 if ( pScroll == aVScrollBottom.get() ) nDelta = -static_cast<tools::Long>(aViewData.PrevCellsY( SC_SPLIT_BOTTOM ));
1228 if (nDelta==0) nDelta=-1;
1229 break;
1230 case ScrollType::PageDown:
1231 if ( pScroll == aHScrollLeft.get() ) nDelta = aViewData.VisibleCellsX( SC_SPLIT_LEFT );
1232 if ( pScroll == aHScrollRight.get() ) nDelta = aViewData.VisibleCellsX( SC_SPLIT_RIGHT );
1233 if ( pScroll == aVScrollTop.get() ) nDelta = aViewData.VisibleCellsY( SC_SPLIT_TOP );
1234 if ( pScroll == aVScrollBottom.get() ) nDelta = aViewData.VisibleCellsY( SC_SPLIT_BOTTOM );
1235 if (nDelta==0) nDelta=1;
1236 break;
1237 default:
1238 {
1239 // only scroll in the correct direction, do not jitter around hidden ranges
1240 tools::Long nScrollMin = 0; // simulate RangeMin
1241 if ( aViewData.GetHSplitMode()==SC_SPLIT_FIX && pScroll == aHScrollRight.get() )
1242 nScrollMin = aViewData.GetFixPosX();
1243 if ( aViewData.GetVSplitMode()==SC_SPLIT_FIX && pScroll == aVScrollBottom.get() )
1244 nScrollMin = aViewData.GetFixPosY();
1245
1246 tools::Long nScrollPos = GetScrollBarPos( *pScroll, bLayoutRTL ) + nScrollMin;
1247 nDelta = nScrollPos - nViewPos;
1248
1249 // tdf#152406 Disable anti-jitter code for scroll wheel events
1250 // After moving thousands of columns to the right via
1251 // horizontal scroll wheel or trackpad swipe events, most
1252 // vertical scroll wheel or trackpad swipe events will trigger
1253 // the anti-jitter code because nScrollPos and nPrevDragPos
1254 // will be equal and nDelta will be overridden and set to zero.
1255 // So, only use the anti-jitter code for mouse drag events.
1256 if ( eType == ScrollType::Drag )
1257 {
1258 if ( nScrollPos > nPrevDragPos )
1259 {
1260 if (nDelta<0) nDelta=0;
1261 }
1262 else if ( nScrollPos < nPrevDragPos )
1263 {
1264 if (nDelta>0) nDelta=0;
1265 }
1266 else
1267 nDelta = 0;
1268 }
1269 else if ( bHoriz )
1270 {
1271 // tdf#135478 Reduce sensitivity of horizontal scrollwheel
1272 // Problem: at least on macOS, swipe events are very
1273 // precise. So, when swiping at a slight angle off of
1274 // vertical, swipe events will include a small amount
1275 // of horizontal movement. Since horizontal swipe units
1276 // are measured in cell widths, these small amounts of
1277 // horizontal movement results in shifting many columns
1278 // to the right or left while swiping almost vertically.
1279 // So my hacky fix is to reduce the amount of horizontal
1280 // swipe events to roughly match the "visual distance"
1281 // of vertical swipe events.
1282 // The reduction factor is arbitrary but is set to
1283 // roughly the ratio of default cell width divided by
1284 // default cell height. This hacky fix isn't a perfect
1285 // fix, but hopefully it reduces the amount of
1286 // unexpected horizontal shifting while swiping
1287 // vertically to a tolerable amount for most users.
1288 // Note: the potential downside of doing this is that
1289 // some users might find horizontal swiping to be
1290 // slower than they are used to. If that becomes an
1291 // issue for enough users, the reduction factor may
1292 // need to be lowered to find a good balance point.
1293 #ifdef _WIN32
1294 static const tools::Long nHScrollReductionFactor = 3;
1295 #else
1296 static const tools::Long nHScrollReductionFactor = 8;
1297 #endif
1298
1299 // tdf#161945 increase sensitivity for negative horizontal deltas
1300 // A side effect of the anti-jitter code is that it tends
1301 // to reduce the sensitivity of horizontal scroll events
1302 // towards the first column. It is particularly noticeable
1303 // with horizontal scroll events from a scrollwheel when
1304 // the view position is in column B or C. This results in
1305 // a very small delta from the anti-jitter code.
1306 // So, to balance things out, apply a constant adjustment
1307 // factor to increase the sensitivity more for small deltas
1308 // than for large deltas.
1309 static const tools::Long nHScrollNegativeDeltaAdjustmentFactor = -1;
1310 if ( nDelta < 0 )
1311 nDelta += nHScrollNegativeDeltaAdjustmentFactor;
1312
1313 if ( pScroll == aHScrollLeft.get() )
1314 {
1315 mnPendingaHScrollLeftDelta += nDelta;
1316 nDelta = 0;
1317 if ( abs(mnPendingaHScrollLeftDelta) > nHScrollReductionFactor )
1318 {
1319 nDelta = mnPendingaHScrollLeftDelta / nHScrollReductionFactor;
1320 mnPendingaHScrollLeftDelta = mnPendingaHScrollLeftDelta % nHScrollReductionFactor;
1321 }
1322 }
1323 else
1324 {
1325 mnPendingaHScrollRightDelta += nDelta;
1326 nDelta = 0;
1327 if ( abs(mnPendingaHScrollRightDelta) > nHScrollReductionFactor )
1328 {
1329 nDelta = mnPendingaHScrollRightDelta / nHScrollReductionFactor;
1330 mnPendingaHScrollRightDelta = mnPendingaHScrollRightDelta % nHScrollReductionFactor;
1331 }
1332 }
1333
1334 bUpdateHorizontalScrollbars = true;
1335 }
1336
1337 nPrevDragPos = nScrollPos;
1338 }
1339 break;
1340 }
1341
1342 if (nDelta)
1343 {
1344 bool bUpdate = ( eType != ScrollType::Drag ); // don't alter the ranges while dragging
1345 if ( bHoriz )
1346 ScrollX( nDelta, (pScroll == aHScrollLeft.get()) ? SC_SPLIT_LEFT : SC_SPLIT_RIGHT, bUpdate );
1347 else
1348 ScrollY( nDelta, (pScroll == aVScrollTop.get()) ? SC_SPLIT_TOP : SC_SPLIT_BOTTOM, bUpdate );
1349 }
1350
1351 // tdf#161945 update horizontal scrollbar position to match tab view
1352 // While the fix for tdf#135478 reduces the horizontal scroll delta
1353 // applied to the tab view, the horizontal scrollbar is set before
1354 // that with the original delta. As a result, the horizontal scrollbar
1355 // is now mispositioned so update the horizontal scrollbar position
1356 // to match the position of the tab view's visible columns.
1357 if ( bUpdateHorizontalScrollbars )
1358 UpdateScrollBars( COLUMN_HEADER );
1359 }
1360
1361 void ScTabView::ScrollX( tools::Long nDeltaX, ScHSplitPos eWhich, bool bUpdBars )
1362 {
1363 ScDocument& rDoc = aViewData.GetDocument();
1364 SCCOL nOldX = aViewData.GetPosX(eWhich);
1365 SCCOL nNewX = nOldX + static_cast<SCCOL>(nDeltaX);
1366 if ( nNewX < 0 )
1367 {
1368 nDeltaX -= nNewX;
1369 nNewX = 0;
1370 }
1371 if ( nNewX > rDoc.MaxCol() )
1372 {
1373 nDeltaX -= nNewX - rDoc.MaxCol();
1374 nNewX = rDoc.MaxCol();
1375 }
1376
1377 SCCOL nDir = ( nDeltaX > 0 ) ? 1 : -1;
1378 SCTAB nTab = aViewData.GetTabNo();
1379 while ( rDoc.ColHidden(nNewX, nTab) &&
1380 nNewX+nDir >= 0 && nNewX+nDir <= rDoc.MaxCol() )
1381 nNewX = sal::static_int_cast<SCCOL>( nNewX + nDir );
1382
1383 // freeze
1384
1385 if (aViewData.GetHSplitMode() == SC_SPLIT_FIX)
1386 {
1387 if (eWhich == SC_SPLIT_LEFT)
1388 nNewX = nOldX; // always keep the left part
1389 else
1390 {
1391 SCCOL nFixX = aViewData.GetFixPosX();
1392 if (nNewX < nFixX)
1393 nNewX = nFixX;
1394 }
1395 }
1396 if (nNewX == nOldX)
1397 return;
1398
1399 HideAllCursors();
1400
1401 if ( nNewX >= 0 && nNewX <= rDoc.MaxCol() && nDeltaX )
1402 {
1403 SCCOL nTrackX = std::max( nOldX, nNewX );
1404
1405 // with VCL Update() affects all windows at the moment, that is why
1406 // calling Update after scrolling of the GridWindow would possibly
1407 // already have painted the column/row bar with updated position. -
1408 // Therefore call Update once before on column/row bar
1409 if (pColBar[eWhich])
1410 pColBar[eWhich]->PaintImmediately();
1411
1412 tools::Long nOldPos = aViewData.GetScrPos( nTrackX, 0, eWhich ).X();
1413 aViewData.SetPosX( eWhich, nNewX );
1414 tools::Long nDiff = aViewData.GetScrPos( nTrackX, 0, eWhich ).X() - nOldPos;
1415
1416 if ( eWhich==SC_SPLIT_LEFT )
1417 {
1418 pGridWin[SC_SPLIT_BOTTOMLEFT]->ScrollPixel( nDiff, 0 );
1419 if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
1420 pGridWin[SC_SPLIT_TOPLEFT]->ScrollPixel( nDiff, 0 );
1421 }
1422 else
1423 {
1424 pGridWin[SC_SPLIT_BOTTOMRIGHT]->ScrollPixel( nDiff, 0 );
1425 if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
1426 pGridWin[SC_SPLIT_TOPRIGHT]->ScrollPixel( nDiff, 0 );
1427 }
1428 if (pColBar[eWhich]) { pColBar[eWhich]->Scroll( nDiff,0 ); pColBar[eWhich]->PaintImmediately(); }
1429 if (pColOutline[eWhich]) pColOutline[eWhich]->ScrollPixel( nDiff );
1430 if (bUpdBars)
1431 UpdateScrollBars();
1432 }
1433
1434 if (nDeltaX==1 || nDeltaX==-1)
1435 pGridWin[aViewData.GetActivePart()]->PaintImmediately();
1436
1437 ShowAllCursors();
1438
1439 SetNewVisArea(); // MapMode must already be set
1440
1441 TestHintWindow();
1442 }
1443
1444 void ScTabView::ScrollY( tools::Long nDeltaY, ScVSplitPos eWhich, bool bUpdBars )
1445 {
1446 ScDocument& rDoc = aViewData.GetDocument();
1447 SCROW nOldY = aViewData.GetPosY(eWhich);
1448 SCROW nNewY = nOldY + static_cast<SCROW>(nDeltaY);
1449 if ( nNewY < 0 )
1450 {
1451 nDeltaY -= nNewY;
1452 nNewY = 0;
1453 }
1454 if ( nNewY > rDoc.MaxRow() )
1455 {
1456 nDeltaY -= nNewY - rDoc.MaxRow();
1457 nNewY = rDoc.MaxRow();
1458 }
1459
1460 SCROW nDir = ( nDeltaY > 0 ) ? 1 : -1;
1461 SCTAB nTab = aViewData.GetTabNo();
1462 while ( rDoc.RowHidden(nNewY, nTab) &&
1463 nNewY+nDir >= 0 && nNewY+nDir <= rDoc.MaxRow() )
1464 nNewY += nDir;
1465
1466 // freeze
1467
1468 if (aViewData.GetVSplitMode() == SC_SPLIT_FIX)
1469 {
1470 if (eWhich == SC_SPLIT_TOP)
1471 nNewY = nOldY; // always keep the upper part
1472 else
1473 {
1474 SCROW nFixY = aViewData.GetFixPosY();
1475 if (nNewY < nFixY)
1476 nNewY = nFixY;
1477 }
1478 }
1479 if (nNewY == nOldY)
1480 return;
1481
1482 HideAllCursors();
1483
1484 if ( nNewY >= 0 && nNewY <= rDoc.MaxRow() && nDeltaY )
1485 {
1486 SCROW nTrackY = std::max( nOldY, nNewY );
1487
1488 // adjust row headers before the actual scrolling, so it does not get painted twice
1489 // PosY may then also not be set yet, pass on new value
1490 SCROW nUNew = nNewY;
1491 UpdateHeaderWidth( &eWhich, &nUNew ); // adjust row headers
1492
1493 if (pRowBar[eWhich])
1494 pRowBar[eWhich]->PaintImmediately();
1495
1496 tools::Long nOldPos = aViewData.GetScrPos( 0, nTrackY, eWhich ).Y();
1497 aViewData.SetPosY( eWhich, nNewY );
1498 tools::Long nDiff = aViewData.GetScrPos( 0, nTrackY, eWhich ).Y() - nOldPos;
1499
1500 if ( eWhich==SC_SPLIT_TOP )
1501 {
1502 pGridWin[SC_SPLIT_TOPLEFT]->ScrollPixel( 0, nDiff );
1503 if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE )
1504 pGridWin[SC_SPLIT_TOPRIGHT]->ScrollPixel( 0, nDiff );
1505 }
1506 else
1507 {
1508 pGridWin[SC_SPLIT_BOTTOMLEFT]->ScrollPixel( 0, nDiff );
1509 if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE )
1510 pGridWin[SC_SPLIT_BOTTOMRIGHT]->ScrollPixel( 0, nDiff );
1511 }
1512 if (pRowBar[eWhich]) { pRowBar[eWhich]->Scroll( 0,nDiff ); pRowBar[eWhich]->PaintImmediately(); }
1513 if (pRowOutline[eWhich]) pRowOutline[eWhich]->ScrollPixel( nDiff );
1514 if (bUpdBars)
1515 UpdateScrollBars();
1516 }
1517
1518 if (nDeltaY==1 || nDeltaY==-1)
1519 pGridWin[aViewData.GetActivePart()]->PaintImmediately();
1520
1521 ShowAllCursors();
1522
1523 SetNewVisArea(); // MapMode must already be set
1524
1525 TestHintWindow();
1526 }
1527
1528 void ScTabView::ScrollLines( tools::Long nDeltaX, tools::Long nDeltaY )
1529 {
1530 ScSplitPos eWhich = aViewData.GetActivePart();
1531 if (nDeltaX)
1532 ScrollX(nDeltaX,WhichH(eWhich));
1533 if (nDeltaY)
1534 ScrollY(nDeltaY,WhichV(eWhich));
1535 }
1536
1537 namespace
1538 {
1539
1540 SCROW lcl_LastVisible( const ScViewData& rViewData )
1541 {
1542 // If many rows are hidden at end of the document,
1543 // then there should not be a switch to wide row headers because of this
1544 ScDocument& rDoc = rViewData.GetDocument();
1545 SCTAB nTab = rViewData.GetTabNo();
1546
1547 SCROW nVis = rDoc.MaxRow();
1548 SCROW startRow;
1549 while ( nVis > 0 && rDoc.GetRowHeight( nVis, nTab, &startRow, nullptr ) == 0 )
1550 nVis = std::max<SCROW>( startRow - 1, 0 );
1551 return nVis;
1552 }
1553
1554 } // anonymous namespace
1555
1556 void ScTabView::UpdateHeaderWidth( const ScVSplitPos* pWhich, const SCROW* pPosY )
1557 {
1558 if (!pRowBar[SC_SPLIT_BOTTOM])
1559 return;
1560
1561 ScDocument& rDoc = aViewData.GetDocument();
1562 SCROW nEndPos = rDoc.MaxRow();
1563 if ( !aViewData.GetViewShell()->GetViewFrame().GetFrame().IsInPlace() )
1564 {
1565 // for OLE Inplace always MAXROW
1566
1567 if ( pWhich && *pWhich == SC_SPLIT_BOTTOM && pPosY )
1568 nEndPos = *pPosY;
1569 else
1570 nEndPos = aViewData.GetPosY( SC_SPLIT_BOTTOM );
1571 nEndPos += aViewData.CellsAtY( nEndPos, 1, SC_SPLIT_BOTTOM ); // VisibleCellsY
1572 if (nEndPos > rDoc.MaxRow())
1573 nEndPos = lcl_LastVisible( aViewData );
1574
1575 if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
1576 {
1577 SCROW nTopEnd;
1578 if ( pWhich && *pWhich == SC_SPLIT_TOP && pPosY )
1579 nTopEnd = *pPosY;
1580 else
1581 nTopEnd = aViewData.GetPosY( SC_SPLIT_TOP );
1582 nTopEnd += aViewData.CellsAtY( nTopEnd, 1, SC_SPLIT_TOP );// VisibleCellsY
1583 if (nTopEnd > rDoc.MaxRow())
1584 nTopEnd = lcl_LastVisible( aViewData );
1585
1586 if ( nTopEnd > nEndPos )
1587 nEndPos = nTopEnd;
1588 }
1589 }
1590
1591 tools::Long nSmall = pRowBar[SC_SPLIT_BOTTOM]->GetSmallWidth();
1592 tools::Long nBig = pRowBar[SC_SPLIT_BOTTOM]->GetBigWidth();
1593 tools::Long nDiff = nBig - nSmall;
1594
1595 if (nEndPos>10000)
1596 nEndPos = 10000;
1597 else if (nEndPos<1) // avoid extra step at 0 (when only one row is visible)
1598 nEndPos = 1;
1599 tools::Long nWidth = nBig - ( 10000 - nEndPos ) * nDiff / 10000;
1600
1601 if (nWidth == pRowBar[SC_SPLIT_BOTTOM]->GetWidth() || bInUpdateHeader)
1602 return;
1603
1604 bInUpdateHeader = true;
1605
1606 pRowBar[SC_SPLIT_BOTTOM]->SetWidth( nWidth );
1607 if (pRowBar[SC_SPLIT_TOP])
1608 pRowBar[SC_SPLIT_TOP]->SetWidth( nWidth );
1609
1610 RepeatResize();
1611
1612 // on VCL there are endless updates (each Update is valid for all windows)
1613 //aCornerButton->Update(); // otherwise this never gets an Update
1614
1615 bInUpdateHeader = false;
1616 }
1617
1618 static void ShowHide( vcl::Window* pWin, bool bShow )
1619 {
1620 OSL_ENSURE(pWin || !bShow, "window is not present");
1621 if (pWin)
1622 pWin->Show(bShow);
1623 }
1624
1625 void ScTabView::UpdateShow()
1626 {
1627 bool bHScrollMode = aViewData.IsHScrollMode();
1628 bool bVScrollMode = aViewData.IsVScrollMode();
1629 bool bTabMode = aViewData.IsTabMode();
1630 bool bOutlMode = aViewData.IsOutlineMode();
1631 bool bHOutline = bOutlMode && lcl_HasColOutline(aViewData);
1632 bool bVOutline = bOutlMode && lcl_HasRowOutline(aViewData);
1633 bool bHeader = aViewData.IsHeaderMode();
1634
1635 bool bShowH = ( aViewData.GetHSplitMode() != SC_SPLIT_NONE );
1636 bool bShowV = ( aViewData.GetVSplitMode() != SC_SPLIT_NONE );
1637
1638 if ( aViewData.GetDocShell()->IsPreview() )
1639 bHScrollMode = bVScrollMode = bTabMode = bHeader = bHOutline = bVOutline = false;
1640
1641 // create Windows
1642
1643 if (bShowH && !pGridWin[SC_SPLIT_BOTTOMRIGHT])
1644 {
1645 pGridWin[SC_SPLIT_BOTTOMRIGHT] = VclPtr<ScGridWindow>::Create( pFrameWin, aViewData, SC_SPLIT_BOTTOMRIGHT );
1646 DoAddWin( pGridWin[SC_SPLIT_BOTTOMRIGHT] );
1647 }
1648 if (bShowV && !pGridWin[SC_SPLIT_TOPLEFT])
1649 {
1650 pGridWin[SC_SPLIT_TOPLEFT] = VclPtr<ScGridWindow>::Create( pFrameWin, aViewData, SC_SPLIT_TOPLEFT );
1651 DoAddWin( pGridWin[SC_SPLIT_TOPLEFT] );
1652 }
1653 if (bShowH && bShowV && !pGridWin[SC_SPLIT_TOPRIGHT])
1654 {
1655 pGridWin[SC_SPLIT_TOPRIGHT] = VclPtr<ScGridWindow>::Create( pFrameWin, aViewData, SC_SPLIT_TOPRIGHT );
1656 DoAddWin( pGridWin[SC_SPLIT_TOPRIGHT] );
1657 }
1658
1659 if (bHOutline && !pColOutline[SC_SPLIT_LEFT])
1660 pColOutline[SC_SPLIT_LEFT] = VclPtr<ScOutlineWindow>::Create( pFrameWin, SC_OUTLINE_HOR, &aViewData, SC_SPLIT_BOTTOMLEFT );
1661 if (bShowH && bHOutline && !pColOutline[SC_SPLIT_RIGHT])
1662 pColOutline[SC_SPLIT_RIGHT] = VclPtr<ScOutlineWindow>::Create( pFrameWin, SC_OUTLINE_HOR, &aViewData, SC_SPLIT_BOTTOMRIGHT );
1663
1664 if (bVOutline && !pRowOutline[SC_SPLIT_BOTTOM])
1665 pRowOutline[SC_SPLIT_BOTTOM] = VclPtr<ScOutlineWindow>::Create( pFrameWin, SC_OUTLINE_VER, &aViewData, SC_SPLIT_BOTTOMLEFT );
1666 if (bShowV && bVOutline && !pRowOutline[SC_SPLIT_TOP])
1667 pRowOutline[SC_SPLIT_TOP] = VclPtr<ScOutlineWindow>::Create( pFrameWin, SC_OUTLINE_VER, &aViewData, SC_SPLIT_TOPLEFT );
1668
1669 if (bShowH && bHeader && !pColBar[SC_SPLIT_RIGHT])
1670 pColBar[SC_SPLIT_RIGHT] = VclPtr<ScColBar>::Create( pFrameWin, SC_SPLIT_RIGHT,
1671 &aHdrFunc, pHdrSelEng.get(), this );
1672 if (bShowV && bHeader && !pRowBar[SC_SPLIT_TOP])
1673 pRowBar[SC_SPLIT_TOP] = VclPtr<ScRowBar>::Create( pFrameWin, SC_SPLIT_TOP,
1674 &aHdrFunc, pHdrSelEng.get(), this );
1675
1676 // show Windows
1677
1678 ShowHide( aHScrollLeft.get(), bHScrollMode );
1679 ShowHide( aHScrollRight.get(), bShowH && bHScrollMode );
1680 ShowHide( aVScrollBottom.get(), bVScrollMode );
1681 ShowHide( aVScrollTop.get(), bShowV && bVScrollMode );
1682
1683 ShowHide( pHSplitter, bHScrollMode || bShowH ); // always generated
1684 ShowHide( pVSplitter, bVScrollMode || bShowV );
1685 ShowHide( pTabControl, bTabMode );
1686
1687 // from here dynamically generated
1688
1689 ShowHide( pGridWin[SC_SPLIT_BOTTOMRIGHT], bShowH );
1690 ShowHide( pGridWin[SC_SPLIT_TOPLEFT], bShowV );
1691 ShowHide( pGridWin[SC_SPLIT_TOPRIGHT], bShowH && bShowV );
1692
1693 ShowHide( pColOutline[SC_SPLIT_LEFT], bHOutline );
1694 ShowHide( pColOutline[SC_SPLIT_RIGHT], bShowH && bHOutline );
1695
1696 ShowHide( pRowOutline[SC_SPLIT_BOTTOM], bVOutline );
1697 ShowHide( pRowOutline[SC_SPLIT_TOP], bShowV && bVOutline );
1698
1699 ShowHide( pColBar[SC_SPLIT_RIGHT], bShowH && bHeader );
1700 ShowHide( pRowBar[SC_SPLIT_TOP], bShowV && bHeader );
1701
1702 //! register new Gridwindows
1703 }
1704
1705 bool ScTabView::UpdateVisibleRange()
1706 {
1707 bool bChanged = false;
1708 for (VclPtr<ScGridWindow> & pWin : pGridWin)
1709 {
1710 if (!pWin || !pWin->IsVisible())
1711 continue;
1712
1713 if (pWin->UpdateVisibleRange())
1714 bChanged = true;
1715 }
1716
1717 return bChanged;
1718 }
1719
1720 // --- Splitter --------------------------------------------------------
1721
1722 IMPL_LINK( ScTabView, SplitHdl, Splitter*, pSplitter, void )
1723 {
1724 if ( pSplitter == pHSplitter )
1725 DoHSplit( pHSplitter->GetSplitPosPixel() );
1726 else
1727 DoVSplit( pVSplitter->GetSplitPosPixel() );
1728
1729 if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX || aViewData.GetVSplitMode() == SC_SPLIT_FIX )
1730 FreezeSplitters( true );
1731
1732 DoResize( aBorderPos, aFrameSize );
1733 }
1734
1735 void ScTabView::DoHSplit(tools::Long nSplitPos)
1736 {
1737 // nSplitPos is the real pixel position on the frame window,
1738 // mirroring for RTL has to be done here.
1739
1740 bool bLayoutRTL = aViewData.GetDocument().IsLayoutRTL( aViewData.GetTabNo() );
1741 if ( bLayoutRTL )
1742 nSplitPos = pFrameWin->GetOutputSizePixel().Width() - nSplitPos - 1;
1743
1744 tools::Long nMinPos;
1745 tools::Long nMaxPos;
1746
1747 nMinPos = SPLIT_MARGIN;
1748 if ( pRowBar[SC_SPLIT_BOTTOM] && pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width() >= nMinPos )
1749 nMinPos = pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width() + 1;
1750 nMaxPos = aFrameSize.Width() - SPLIT_MARGIN;
1751
1752 ScSplitMode aOldMode = aViewData.GetHSplitMode();
1753 ScSplitMode aNewMode = SC_SPLIT_NORMAL;
1754
1755 aViewData.SetHSplitPos( nSplitPos );
1756 if ( nSplitPos < nMinPos || nSplitPos > nMaxPos )
1757 aNewMode = SC_SPLIT_NONE;
1758
1759 aViewData.SetHSplitMode( aNewMode );
1760
1761 if ( aNewMode == aOldMode )
1762 return;
1763
1764 UpdateShow(); // before ActivatePart !!
1765
1766 if ( aNewMode == SC_SPLIT_NONE )
1767 {
1768 if (aViewData.GetActivePart() == SC_SPLIT_TOPRIGHT)
1769 ActivatePart( SC_SPLIT_TOPLEFT );
1770 if (aViewData.GetActivePart() == SC_SPLIT_BOTTOMRIGHT)
1771 ActivatePart( SC_SPLIT_BOTTOMLEFT );
1772 }
1773 else
1774 {
1775 // coverity[ tainted_data_return : FALSE ] version 2023.12.2
1776 SCCOL nOldDelta = aViewData.GetPosX( SC_SPLIT_LEFT );
1777 tools::Long nLeftWidth = nSplitPos - pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width();
1778 if ( nLeftWidth < 0 ) nLeftWidth = 0;
1779 SCCOL nNewDelta = nOldDelta + aViewData.CellsAtX( nOldDelta, 1, SC_SPLIT_LEFT,
1780 static_cast<sal_uInt16>(nLeftWidth) );
1781 ScDocument& rDoc = aViewData.GetDocument();
1782 if ( nNewDelta > rDoc.MaxCol() )
1783 nNewDelta = rDoc.MaxCol();
1784 aViewData.SetPosX( SC_SPLIT_RIGHT, nNewDelta );
1785 if ( nNewDelta > aViewData.GetCurX() )
1786 ActivatePart( (WhichV(aViewData.GetActivePart()) == SC_SPLIT_BOTTOM) ?
1787 SC_SPLIT_BOTTOMLEFT : SC_SPLIT_TOPLEFT );
1788 else
1789 ActivatePart( (WhichV(aViewData.GetActivePart()) == SC_SPLIT_BOTTOM) ?
1790 SC_SPLIT_BOTTOMRIGHT : SC_SPLIT_TOPRIGHT );
1791 }
1792
1793 // Form Layer needs to know the visible part of all windows
1794 // that is why MapMode must already be correct here
1795 SyncGridWindowMapModeFromDrawMapMode();
1796 SetNewVisArea();
1797
1798 PaintGrid();
1799 PaintTop();
1800
1801 InvalidateSplit();
1802 }
1803
1804 void ScTabView::DoVSplit(tools::Long nSplitPos)
1805 {
1806 tools::Long nMinPos;
1807 tools::Long nMaxPos;
1808 SCROW nOldDelta;
1809
1810 nMinPos = SPLIT_MARGIN;
1811 if ( pColBar[SC_SPLIT_LEFT] && pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height() >= nMinPos )
1812 nMinPos = pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height() + 1;
1813 nMaxPos = aFrameSize.Height() - SPLIT_MARGIN;
1814
1815 ScSplitMode aOldMode = aViewData.GetVSplitMode();
1816 ScSplitMode aNewMode = SC_SPLIT_NORMAL;
1817
1818 aViewData.SetVSplitPos( nSplitPos );
1819 if ( nSplitPos < nMinPos || nSplitPos > nMaxPos )
1820 aNewMode = SC_SPLIT_NONE;
1821
1822 aViewData.SetVSplitMode( aNewMode );
1823
1824 if ( aNewMode == aOldMode )
1825 return;
1826
1827 UpdateShow(); // before ActivatePart !!
1828
1829 if ( aNewMode == SC_SPLIT_NONE )
1830 {
1831 nOldDelta = aViewData.GetPosY( SC_SPLIT_TOP );
1832 aViewData.SetPosY( SC_SPLIT_BOTTOM, nOldDelta );
1833
1834 if (aViewData.GetActivePart() == SC_SPLIT_TOPLEFT)
1835 ActivatePart( SC_SPLIT_BOTTOMLEFT );
1836 if (aViewData.GetActivePart() == SC_SPLIT_TOPRIGHT)
1837 ActivatePart( SC_SPLIT_BOTTOMRIGHT );
1838 }
1839 else
1840 {
1841 if ( aOldMode == SC_SPLIT_NONE )
1842 {
1843 // coverity[ tainted_data_return : FALSE ] version 2023.12.2
1844 nOldDelta = aViewData.GetPosY( SC_SPLIT_BOTTOM );
1845 }
1846 else
1847 nOldDelta = aViewData.GetPosY( SC_SPLIT_TOP );
1848
1849 aViewData.SetPosY( SC_SPLIT_TOP, nOldDelta );
1850 tools::Long nTopHeight = nSplitPos - pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height();
1851 if ( nTopHeight < 0 ) nTopHeight = 0;
1852 SCROW nNewDelta = nOldDelta + aViewData.CellsAtY( nOldDelta, 1, SC_SPLIT_TOP,
1853 static_cast<sal_uInt16>(nTopHeight) );
1854 ScDocument& rDoc = aViewData.GetDocument();
1855 if ( nNewDelta > rDoc.MaxRow() )
1856 nNewDelta = rDoc.MaxRow();
1857 aViewData.SetPosY( SC_SPLIT_BOTTOM, nNewDelta );
1858 if ( nNewDelta > aViewData.GetCurY() )
1859 ActivatePart( (WhichH(aViewData.GetActivePart()) == SC_SPLIT_LEFT) ?
1860 SC_SPLIT_TOPLEFT : SC_SPLIT_TOPRIGHT );
1861 else
1862 ActivatePart( (WhichH(aViewData.GetActivePart()) == SC_SPLIT_LEFT) ?
1863 SC_SPLIT_BOTTOMLEFT : SC_SPLIT_BOTTOMRIGHT );
1864 }
1865
1866 // Form Layer needs to know the visible part of all windows
1867 // that is why MapMode must already be correct here
1868 SyncGridWindowMapModeFromDrawMapMode();
1869 SetNewVisArea();
1870
1871 PaintGrid();
1872 PaintLeft();
1873
1874 InvalidateSplit();
1875 }
1876
1877 Point ScTabView::GetInsertPos() const
1878 {
1879 ScDocument& rDoc = aViewData.GetDocument();
1880 SCCOL nCol = aViewData.GetCurX();
1881 SCROW nRow = aViewData.GetCurY();
1882 SCTAB nTab = aViewData.GetTabNo();
1883 tools::Long nPosX = 0;
1884 for (SCCOL i=0; i<nCol; i++)
1885 nPosX += rDoc.GetColWidth(i,nTab);
1886 nPosX = o3tl::convert(nPosX, o3tl::Length::twip, o3tl::Length::mm100);
1887 if ( rDoc.IsNegativePage( nTab ) )
1888 nPosX = -nPosX;
1889 tools::Long nPosY = rDoc.GetRowHeight( 0, nRow-1, nTab);
1890 nPosY = o3tl::convert(nPosY, o3tl::Length::twip, o3tl::Length::mm100);
1891 return Point(nPosX,nPosY);
1892 }
1893
1894 Point ScTabView::GetChartInsertPos( const Size& rSize, const ScRange& rCellRange )
1895 {
1896 Point aInsertPos;
1897 const tools::Long nBorder = 100; // leave 1mm for border
1898 tools::Long nNeededWidth = rSize.Width() + 2 * nBorder;
1899 tools::Long nNeededHeight = rSize.Height() + 2 * nBorder;
1900
1901 // use the active window, or lower/right if frozen (as in CalcZoom)
1902 ScSplitPos eUsedPart = aViewData.GetActivePart();
1903 if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
1904 eUsedPart = (WhichV(eUsedPart)==SC_SPLIT_TOP) ? SC_SPLIT_TOPRIGHT : SC_SPLIT_BOTTOMRIGHT;
1905 if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX )
1906 eUsedPart = (WhichH(eUsedPart)==SC_SPLIT_LEFT) ? SC_SPLIT_BOTTOMLEFT : SC_SPLIT_BOTTOMRIGHT;
1907
1908 ScGridWindow* pWin = pGridWin[eUsedPart].get();
1909 OSL_ENSURE( pWin, "Window not found" );
1910 if (pWin)
1911 {
1912 ActivatePart( eUsedPart );
1913
1914 // get the visible rectangle in logic units
1915 bool bLOKActive = comphelper::LibreOfficeKit::isActive();
1916 MapMode aDrawMode = pWin->GetDrawMapMode();
1917 tools::Rectangle aVisible(
1918 bLOKActive ?
1919 OutputDevice::LogicToLogic( aViewData.getLOKVisibleArea(), MapMode(MapUnit::MapTwip), MapMode(MapUnit::Map100thMM) )
1920 : pWin->PixelToLogic( tools::Rectangle( Point(0,0), pWin->GetOutputSizePixel() ), aDrawMode ) );
1921
1922 ScDocument& rDoc = aViewData.GetDocument();
1923 SCTAB nTab = aViewData.GetTabNo();
1924 bool bLayoutRTL = rDoc.IsLayoutRTL( nTab );
1925 tools::Long nLayoutSign = bLayoutRTL ? -1 : 1;
1926
1927 tools::Long nDocX = o3tl::convert(rDoc.GetColOffset(rDoc.MaxCol() + 1, nTab), o3tl::Length::twip, o3tl::Length::mm100) * nLayoutSign;
1928 tools::Long nDocY = o3tl::convert(rDoc.GetRowOffset( rDoc.MaxRow() + 1, nTab ), o3tl::Length::twip, o3tl::Length::mm100);
1929
1930 if ( aVisible.Left() * nLayoutSign > nDocX * nLayoutSign )
1931 aVisible.SetLeft( nDocX );
1932 if ( aVisible.Right() * nLayoutSign > nDocX * nLayoutSign )
1933 aVisible.SetRight( nDocX );
1934 if ( aVisible.Top() > nDocY )
1935 aVisible.SetTop( nDocY );
1936 if ( aVisible.Bottom() > nDocY )
1937 aVisible.SetBottom( nDocY );
1938
1939 // get the logic position of the selection
1940
1941 tools::Rectangle aSelection = rDoc.GetMMRect( rCellRange.aStart.Col(), rCellRange.aStart.Row(),
1942 rCellRange.aEnd.Col(), rCellRange.aEnd.Row(), nTab );
1943
1944 if (bLOKActive && bLayoutRTL)
1945 {
1946 // In this case we operate in negative X coordinates. The rectangle aSelection already
1947 // has negative X coordinates. So the x coordinates in the rectangle aVisible(from getLOKVisibleArea)
1948 // need be negated to match.
1949 aVisible = tools::Rectangle(-aVisible.Right(), aVisible.Top(), -aVisible.Left(), aVisible.Bottom());
1950 }
1951
1952 tools::Long nLeftSpace = aSelection.Left() - aVisible.Left();
1953 tools::Long nRightSpace = aVisible.Right() - aSelection.Right();
1954 tools::Long nTopSpace = aSelection.Top() - aVisible.Top();
1955 tools::Long nBottomSpace = aVisible.Bottom() - aSelection.Bottom();
1956
1957 bool bFitLeft = ( nLeftSpace >= nNeededWidth );
1958 bool bFitRight = ( nRightSpace >= nNeededWidth );
1959
1960 if ( bFitLeft || bFitRight )
1961 {
1962 // first preference: completely left or right of the selection
1963
1964 // if both fit, prefer left in RTL mode, right otherwise
1965 bool bPutLeft = bFitLeft && ( bLayoutRTL || !bFitRight );
1966
1967 if ( bPutLeft )
1968 aInsertPos.setX( aSelection.Left() - nNeededWidth );
1969 else
1970 aInsertPos.setX( aSelection.Right() + 1 );
1971
1972 // align with top of selection (is moved again if it doesn't fit)
1973 aInsertPos.setY( std::max( aSelection.Top(), aVisible.Top() ) );
1974 }
1975 else if ( nTopSpace >= nNeededHeight || nBottomSpace >= nNeededHeight )
1976 {
1977 // second preference: completely above or below the selection
1978 if ( nBottomSpace > nNeededHeight ) // bottom is preferred
1979 aInsertPos.setY( aSelection.Bottom() + 1 );
1980 else
1981 aInsertPos.setY( aSelection.Top() - nNeededHeight );
1982
1983 // align with (logic) left edge of selection (moved again if it doesn't fit)
1984 if ( bLayoutRTL )
1985 aInsertPos.setX( std::min( aSelection.Right(), aVisible.Right() ) - nNeededWidth + 1 );
1986 else
1987 aInsertPos.setX( std::max( aSelection.Left(), aVisible.Left() ) );
1988 }
1989 else
1990 {
1991 // place to the (logic) right of the selection and move so it fits
1992
1993 if ( bLayoutRTL )
1994 aInsertPos.setX( aSelection.Left() - nNeededWidth );
1995 else
1996 aInsertPos.setX( aSelection.Right() + 1 );
1997 aInsertPos.setY( std::max( aSelection.Top(), aVisible.Top() ) );
1998 }
1999
2000 // move the position if the object doesn't fit in the screen
2001
2002 tools::Rectangle aCompareRect( aInsertPos, Size( nNeededWidth, nNeededHeight ) );
2003 if ( aCompareRect.Right() > aVisible.Right() )
2004 aInsertPos.AdjustX( -(aCompareRect.Right() - aVisible.Right()) );
2005 if ( aCompareRect.Bottom() > aVisible.Bottom() )
2006 aInsertPos.AdjustY( -(aCompareRect.Bottom() - aVisible.Bottom()) );
2007
2008 if ( aInsertPos.X() < aVisible.Left() )
2009 aInsertPos.setX( aVisible.Left() );
2010 if ( aInsertPos.Y() < aVisible.Top() )
2011 aInsertPos.setY( aVisible.Top() );
2012
2013 // nNeededWidth / nNeededHeight includes all borders - move aInsertPos to the
2014 // object position, inside the border
2015
2016 aInsertPos.AdjustX(nBorder );
2017 aInsertPos.AdjustY(nBorder );
2018 }
2019 return aInsertPos;
2020 }
2021
2022 Point ScTabView::GetChartDialogPos( const Size& rDialogSize, const tools::Rectangle& rLogicChart )
2023 {
2024 // rDialogSize must be in pixels, rLogicChart in 1/100 mm. Return value is in pixels.
2025
2026 Point aRet;
2027
2028 // use the active window, or lower/right if frozen (as in CalcZoom)
2029 ScSplitPos eUsedPart = aViewData.GetActivePart();
2030 if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
2031 eUsedPart = (WhichV(eUsedPart)==SC_SPLIT_TOP) ? SC_SPLIT_TOPRIGHT : SC_SPLIT_BOTTOMRIGHT;
2032 if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX )
2033 eUsedPart = (WhichH(eUsedPart)==SC_SPLIT_LEFT) ? SC_SPLIT_BOTTOMLEFT : SC_SPLIT_BOTTOMRIGHT;
2034
2035 ScGridWindow* pWin = pGridWin[eUsedPart].get();
2036 OSL_ENSURE( pWin, "Window not found" );
2037 if (pWin)
2038 {
2039 MapMode aDrawMode = pWin->GetDrawMapMode();
2040 tools::Rectangle aObjPixel = pWin->LogicToPixel( rLogicChart, aDrawMode );
2041 AbsoluteScreenPixelRectangle aObjAbs( pWin->OutputToAbsoluteScreenPixel( aObjPixel.TopLeft() ),
2042 pWin->OutputToAbsoluteScreenPixel( aObjPixel.BottomRight() ) );
2043
2044 AbsoluteScreenPixelRectangle aDesktop = pWin->GetDesktopRectPixel();
2045 Size aSpace = pWin->LogicToPixel( Size(8, 12), MapMode(MapUnit::MapAppFont));
2046
2047 ScDocument& rDoc = aViewData.GetDocument();
2048 SCTAB nTab = aViewData.GetTabNo();
2049 bool bLayoutRTL = rDoc.IsLayoutRTL( nTab );
2050
2051 bool bCenterHor = false;
2052
2053 if ( aDesktop.Bottom() - aObjAbs.Bottom() >= rDialogSize.Height() + aSpace.Height() )
2054 {
2055 // first preference: below the chart
2056
2057 aRet.setY( aObjAbs.Bottom() + aSpace.Height() );
2058 bCenterHor = true;
2059 }
2060 else if ( aObjAbs.Top() - aDesktop.Top() >= rDialogSize.Height() + aSpace.Height() )
2061 {
2062 // second preference: above the chart
2063
2064 aRet.setY( aObjAbs.Top() - rDialogSize.Height() - aSpace.Height() );
2065 bCenterHor = true;
2066 }
2067 else
2068 {
2069 bool bFitLeft = ( aObjAbs.Left() - aDesktop.Left() >= rDialogSize.Width() + aSpace.Width() );
2070 bool bFitRight = ( aDesktop.Right() - aObjAbs.Right() >= rDialogSize.Width() + aSpace.Width() );
2071
2072 if ( bFitLeft || bFitRight )
2073 {
2074 // if both fit, prefer right in RTL mode, left otherwise
2075 bool bPutRight = bFitRight && ( bLayoutRTL || !bFitLeft );
2076 if ( bPutRight )
2077 aRet.setX( aObjAbs.Right() + aSpace.Width() );
2078 else
2079 aRet.setX( aObjAbs.Left() - rDialogSize.Width() - aSpace.Width() );
2080
2081 // center vertically
2082 aRet.setY( aObjAbs.Top() + ( aObjAbs.GetHeight() - rDialogSize.Height() ) / 2 );
2083 }
2084 else
2085 {
2086 // doesn't fit on any edge - put at the bottom of the screen
2087 aRet.setY( aDesktop.Bottom() - rDialogSize.Height() );
2088 bCenterHor = true;
2089 }
2090 }
2091 if ( bCenterHor )
2092 aRet.setX( aObjAbs.Left() + ( aObjAbs.GetWidth() - rDialogSize.Width() ) / 2 );
2093
2094 // limit to screen (centering might lead to invalid positions)
2095 if ( aRet.X() + rDialogSize.Width() - 1 > aDesktop.Right() )
2096 aRet.setX( aDesktop.Right() - rDialogSize.Width() + 1 );
2097 if ( aRet.X() < aDesktop.Left() )
2098 aRet.setX( aDesktop.Left() );
2099 if ( aRet.Y() + rDialogSize.Height() - 1 > aDesktop.Bottom() )
2100 aRet.setY( aDesktop.Bottom() - rDialogSize.Height() + 1 );
2101 if ( aRet.Y() < aDesktop.Top() )
2102 aRet.setY( aDesktop.Top() );
2103 }
2104
2105 return aRet;
2106 }
2107
2108 void ScTabView::LockModifiers( sal_uInt16 nModifiers )
2109 {
2110 pSelEngine->LockModifiers( nModifiers );
2111 pHdrSelEng->LockModifiers( nModifiers );
2112 }
2113
2114 sal_uInt16 ScTabView::GetLockedModifiers() const
2115 {
2116 return pSelEngine->GetLockedModifiers();
2117 }
2118
2119 Point ScTabView::GetMousePosPixel()
2120 {
2121 Point aPos;
2122 ScGridWindow* pWin = GetActiveWin();
2123
2124 if ( pWin )
2125 aPos = pWin->GetMousePosPixel();
2126
2127 return aPos;
2128 }
2129
2130 void ScTabView::FreezeSplitters( bool bFreeze, SplitMethod eSplitMethod, SCCOLROW nFreezeIndex)
2131 {
2132 if ((eSplitMethod == SC_SPLIT_METHOD_COL || eSplitMethod == SC_SPLIT_METHOD_ROW) && nFreezeIndex < 0)
2133 nFreezeIndex = 0;
2134
2135 ScSplitMode eOldH = aViewData.GetHSplitMode();
2136 ScSplitMode eOldV = aViewData.GetVSplitMode();
2137
2138 ScSplitPos ePos = SC_SPLIT_BOTTOMLEFT;
2139 if ( eOldV != SC_SPLIT_NONE )
2140 ePos = SC_SPLIT_TOPLEFT;
2141 vcl::Window* pWin = pGridWin[ePos];
2142
2143 bool bLayoutRTL = aViewData.GetDocument().IsLayoutRTL( aViewData.GetTabNo() );
2144 bool bUpdateFix = false;
2145
2146 if ( bFreeze )
2147 {
2148 Point aWinStart = pWin->GetPosPixel();
2149 aViewData.GetDocShell()->SetDocumentModified();
2150
2151 Point aSplit;
2152 SCCOL nPosX = 1;
2153 SCROW nPosY = 1;
2154 if (eOldV != SC_SPLIT_NONE || eOldH != SC_SPLIT_NONE)
2155 {
2156 if ( eOldV != SC_SPLIT_NONE && (eSplitMethod == SC_SPLIT_METHOD_ROW || eSplitMethod == SC_SPLIT_METHOD_CURSOR))
2157 aSplit.setY( aViewData.GetVSplitPos() - aWinStart.Y() );
2158
2159 if ( eOldH != SC_SPLIT_NONE && (eSplitMethod == SC_SPLIT_METHOD_COL || eSplitMethod == SC_SPLIT_METHOD_CURSOR))
2160 {
2161 tools::Long nSplitPos = aViewData.GetHSplitPos();
2162 if ( bLayoutRTL )
2163 nSplitPos = pFrameWin->GetOutputSizePixel().Width() - nSplitPos - 1;
2164 aSplit.setX( nSplitPos - aWinStart.X() );
2165 }
2166
2167 aViewData.GetPosFromPixel( aSplit.X(), aSplit.Y(), ePos, nPosX, nPosY );
2168 bool bLeft;
2169 bool bTop;
2170 aViewData.GetMouseQuadrant( aSplit, ePos, nPosX, nPosY, bLeft, bTop );
2171 if (eSplitMethod == SC_SPLIT_METHOD_COL)
2172 nPosX = static_cast<SCCOL>(nFreezeIndex);
2173 else if (!bLeft)
2174 ++nPosX;
2175 if (eSplitMethod == SC_SPLIT_METHOD_ROW)
2176 nPosY = static_cast<SCROW>(nFreezeIndex);
2177 else if (!bTop)
2178 ++nPosY;
2179 }
2180 else
2181 {
2182 switch(eSplitMethod)
2183 {
2184 case SC_SPLIT_METHOD_ROW:
2185 {
2186 nPosX = 0;
2187 nPosY = static_cast<SCROW>(nFreezeIndex);
2188 }
2189 break;
2190 case SC_SPLIT_METHOD_COL:
2191 {
2192 nPosX = static_cast<SCCOL>(nFreezeIndex);
2193 nPosY = 0;
2194 }
2195 break;
2196 case SC_SPLIT_METHOD_CURSOR:
2197 {
2198 nPosX = aViewData.GetCurX();
2199 nPosY = aViewData.GetCurY();
2200 }
2201 break;
2202 }
2203 }
2204
2205 SCROW nTopPos = aViewData.GetPosY(SC_SPLIT_BOTTOM);
2206 SCROW nBottomPos = nPosY;
2207 SCCOL nLeftPos = aViewData.GetPosX(SC_SPLIT_LEFT);
2208 SCCOL nRightPos = nPosX;
2209
2210 if (eSplitMethod == SC_SPLIT_METHOD_ROW || eSplitMethod == SC_SPLIT_METHOD_CURSOR)
2211 {
2212 if (eOldV != SC_SPLIT_NONE)
2213 {
2214 nTopPos = aViewData.GetPosY(SC_SPLIT_TOP);
2215 nBottomPos = std::max(aViewData.GetPosY(SC_SPLIT_BOTTOM), nBottomPos);
2216 }
2217 aSplit = aViewData.GetScrPos(nPosX, nPosY, ePos, true);
2218 if (aSplit.Y() > 0)
2219 {
2220 aViewData.SetVSplitMode(SC_SPLIT_FIX);
2221 aViewData.SetVSplitPos(aSplit.Y() + aWinStart.Y());
2222 aViewData.SetFixPosY(nPosY);
2223
2224 aViewData.SetPosY(SC_SPLIT_TOP, nTopPos);
2225 aViewData.SetPosY(SC_SPLIT_BOTTOM, nBottomPos);
2226 }
2227 else if (nPosY == 1 && eSplitMethod == SC_SPLIT_METHOD_ROW)
2228 {
2229 // Freeze first row, but row 1 is not visible on screen now == special handling
2230 aViewData.SetVSplitMode(SC_SPLIT_FIX);
2231 aViewData.SetFixPosY(nPosY);
2232
2233 aViewData.SetPosY(SC_SPLIT_TOP, 0);
2234 bUpdateFix = true;
2235 }
2236 else
2237 aViewData.SetVSplitMode(SC_SPLIT_NONE);
2238 }
2239
2240 if (eSplitMethod == SC_SPLIT_METHOD_COL || eSplitMethod == SC_SPLIT_METHOD_CURSOR)
2241 {
2242 if (eOldH != SC_SPLIT_NONE)
2243 {
2244 if (aViewData.GetPosX(SC_SPLIT_RIGHT) > nRightPos)
2245 nRightPos = aViewData.GetPosX(SC_SPLIT_RIGHT);
2246 }
2247 aSplit = aViewData.GetScrPos( nPosX, nPosY, ePos, true );
2248 if (nPosX > aViewData.GetPosX(SC_SPLIT_LEFT)) // (aSplit.X() > 0) doesn't work for RTL
2249 {
2250 tools::Long nSplitPos = aSplit.X() + aWinStart.X();
2251 if ( bLayoutRTL )
2252 nSplitPos = pFrameWin->GetOutputSizePixel().Width() - nSplitPos - 1;
2253
2254 aViewData.SetHSplitMode( SC_SPLIT_FIX );
2255 aViewData.SetHSplitPos( nSplitPos );
2256 aViewData.SetFixPosX( nPosX );
2257
2258 aViewData.SetPosX(SC_SPLIT_LEFT, nLeftPos);
2259 aViewData.SetPosX(SC_SPLIT_RIGHT, nRightPos);
2260 }
2261 else if (nPosX == 1 && eSplitMethod == SC_SPLIT_METHOD_COL)
2262 {
2263 // Freeze first column, but col A is not visible on screen now == special handling
2264 aViewData.SetHSplitMode(SC_SPLIT_FIX);
2265 aViewData.SetFixPosX(nPosX);
2266
2267 aViewData.SetPosX(SC_SPLIT_RIGHT, aViewData.GetPosX(SC_SPLIT_LEFT));
2268 aViewData.SetPosX(SC_SPLIT_LEFT, 0);
2269 bUpdateFix = true;
2270 }
2271 else
2272 aViewData.SetHSplitMode( SC_SPLIT_NONE );
2273 }
2274 }
2275 else // unfreeze
2276 {
2277 if ( eOldH == SC_SPLIT_FIX )
2278 aViewData.SetHSplitMode( SC_SPLIT_NORMAL );
2279 if ( eOldV == SC_SPLIT_FIX )
2280 aViewData.SetVSplitMode( SC_SPLIT_NORMAL );
2281 }
2282
2283 // Form Layer needs to know the visible part of all windows
2284 // that is why MapMode must already be correct here
2285 SyncGridWindowMapModeFromDrawMapMode();
2286 SetNewVisArea();
2287
2288 RepeatResize(bUpdateFix);
2289
2290 UpdateShow();
2291 PaintLeft();
2292 PaintTop();
2293 PaintGrid();
2294
2295 // SC_FOLLOW_NONE: only update active part
2296 AlignToCursor( aViewData.GetCurX(), aViewData.GetCurY(), SC_FOLLOW_NONE );
2297 UpdateAutoFillMark();
2298
2299 InvalidateSplit();
2300 }
2301
2302 void ScTabView::RemoveSplit()
2303 {
2304 if (aViewData.GetHSplitMode() == SC_SPLIT_FIX || aViewData.GetVSplitMode() == SC_SPLIT_FIX)
2305 aViewData.GetDocShell()->SetDocumentModified();
2306 DoHSplit( 0 );
2307 DoVSplit( 0 );
2308 RepeatResize();
2309 }
2310
2311 void ScTabView::SplitAtCursor()
2312 {
2313 ScSplitPos ePos = SC_SPLIT_BOTTOMLEFT;
2314 if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
2315 ePos = SC_SPLIT_TOPLEFT;
2316 vcl::Window* pWin = pGridWin[ePos];
2317 Point aWinStart = pWin->GetPosPixel();
2318
2319 SCCOL nPosX = aViewData.GetCurX();
2320 SCROW nPosY = aViewData.GetCurY();
2321 Point aSplit = aViewData.GetScrPos( nPosX, nPosY, ePos, true );
2322 if ( nPosX > 0 )
2323 DoHSplit( aSplit.X() + aWinStart.X() );
2324 else
2325 DoHSplit( 0 );
2326 if ( nPosY > 0 )
2327 DoVSplit( aSplit.Y() + aWinStart.Y() );
2328 else
2329 DoVSplit( 0 );
2330 RepeatResize();
2331 }
2332
2333 void ScTabView::SplitAtPixel( const Point& rPixel )
2334 {
2335 // pixel is relative to the entire View, not to the first GridWin
2336
2337 if ( rPixel.X() > 0 )
2338 DoHSplit( rPixel.X() );
2339 else
2340 DoHSplit( 0 );
2341 if ( rPixel.Y() > 0 )
2342 DoVSplit( rPixel.Y() );
2343 else
2344 DoVSplit( 0 );
2345 RepeatResize();
2346 }
2347
2348 void ScTabView::InvalidateSplit()
2349 {
2350 SfxBindings& rBindings = aViewData.GetBindings();
2351 rBindings.Invalidate( SID_WINDOW_SPLIT );
2352 rBindings.Invalidate( SID_WINDOW_FIX );
2353 rBindings.Invalidate( SID_WINDOW_FIX_COL );
2354 rBindings.Invalidate( SID_WINDOW_FIX_ROW );
2355
2356 pHSplitter->SetFixed( aViewData.GetHSplitMode() == SC_SPLIT_FIX );
2357 pVSplitter->SetFixed( aViewData.GetVSplitMode() == SC_SPLIT_FIX );
2358 }
2359
2360 void ScTabView::SetNewVisArea()
2361 {
2362 // Draw-MapMode must be set for Controls when VisAreaChanged
2363 // (also when Edit-MapMode is set instead)
2364 MapMode aOldMode[4];
2365 MapMode aDrawMode[4];
2366 sal_uInt16 i;
2367 for (i=0; i<4; i++)
2368 if (pGridWin[i])
2369 {
2370 aOldMode[i] = pGridWin[i]->GetMapMode();
2371 aDrawMode[i] = pGridWin[i]->GetDrawMapMode();
2372 if (aDrawMode[i] != aOldMode[i])
2373 pGridWin[i]->SetMapMode(aDrawMode[i]);
2374 }
2375
2376 vcl::Window* pActive = pGridWin[aViewData.GetActivePart()];
2377 if (pActive)
2378 aViewData.GetViewShell()->VisAreaChanged();
2379 if (pDrawView)
2380 pDrawView->VisAreaChanged(nullptr); // no window passed on -> for all windows
2381
2382 UpdateAllOverlays(); // #i79909# with drawing MapMode set
2383
2384 for (i=0; i<4; i++)
2385 if (pGridWin[i] && aDrawMode[i] != aOldMode[i])
2386 {
2387 pGridWin[i]->flushOverlayManager(); // #i79909# flush overlays before switching to edit MapMode
2388 pGridWin[i]->SetMapMode(aOldMode[i]);
2389 }
2390
2391 SfxViewFrame& rViewFrame = aViewData.GetViewShell()->GetViewFrame();
2392 SfxFrame& rFrame = rViewFrame.GetFrame();
2393 css::uno::Reference<css::frame::XController> xController = rFrame.GetController();
2394 if (xController.is())
2395 {
2396 ScTabViewObj* pImp = dynamic_cast<ScTabViewObj*>( xController.get() );
2397 if (pImp)
2398 pImp->VisAreaChanged();
2399 }
2400
2401 if (GetViewData().HasEditView(GetViewData().GetActivePart()))
2402 {
2403 EditView *pEditView = GetViewData().GetEditView(GetViewData().GetActivePart());
2404 vcl::Cursor *pInPlaceCrsr = pEditView->GetCursor();
2405 bool bInPlaceVisCursor = pInPlaceCrsr && pInPlaceCrsr->IsVisible();
2406
2407 if (bInPlaceVisCursor)
2408 pInPlaceCrsr->Hide();
2409
2410 ScGridWindow *pGridWindow = GetViewData().GetActiveWin();
2411 pGridWindow->DrawEditView(*pGridWindow->GetOutDev(), pEditView);
2412
2413 pGridWindow->flushOverlayManager();
2414 pGridWindow->GetOutDev()->SetMapMode(GetViewData().GetLogicMode());
2415
2416 if (bInPlaceVisCursor)
2417 pInPlaceCrsr->Show();
2418 }
2419
2420 if (aViewData.GetViewShell()->HasAccessibilityObjects())
2421 aViewData.GetViewShell()->BroadcastAccessibility(SfxHint(SfxHintId::ScAccVisAreaChanged));
2422 }
2423
2424 bool ScTabView::HasPageFieldDataAtCursor() const
2425 {
2426 ScGridWindow* pWin = pGridWin[aViewData.GetActivePart()].get();
2427 SCCOL nCol = aViewData.GetCurX();
2428 SCROW nRow = aViewData.GetCurY();
2429 if (pWin)
2430 return pWin->GetDPFieldOrientation( nCol, nRow ) == sheet::DataPilotFieldOrientation_PAGE;
2431
2432 return false;
2433 }
2434
2435 void ScTabView::StartDataSelect()
2436 {
2437 ScGridWindow* pWin = pGridWin[aViewData.GetActivePart()].get();
2438 SCCOL nCol = aViewData.GetCurX();
2439 SCROW nRow = aViewData.GetCurY();
2440
2441 if (!pWin)
2442 return;
2443
2444 switch (pWin->GetDPFieldOrientation(nCol, nRow))
2445 {
2446 case sheet::DataPilotFieldOrientation_PAGE:
2447 // #i36598# If the cursor is on a page field's data cell,
2448 // no meaningful input is possible anyway, so this function
2449 // can be used to select a page field entry.
2450 pWin->LaunchPageFieldMenu( nCol, nRow );
2451 return;
2452 case sheet::DataPilotFieldOrientation_COLUMN:
2453 case sheet::DataPilotFieldOrientation_ROW:
2454 pWin->LaunchDPFieldMenu( nCol, nRow );
2455 return;
2456 default:
2457 ;
2458 }
2459
2460 // Do autofilter if the current cell has autofilter button. Otherwise do
2461 // a normal data select popup.
2462 const ScMergeFlagAttr* pAttr =
2463 aViewData.GetDocument().GetAttr(
2464 nCol, nRow, aViewData.GetTabNo(), ATTR_MERGE_FLAG);
2465
2466 if (pAttr->HasAutoFilter())
2467 pWin->LaunchAutoFilterMenu(nCol, nRow);
2468 else
2469 pWin->LaunchDataSelectMenu(nCol, nRow);
2470 }
2471
2472 void ScTabView::EnableRefInput(bool bFlag)
2473 {
2474 aHScrollLeft->EnableInput(bFlag);
2475 aHScrollRight->EnableInput(bFlag);
2476 aVScrollBottom->EnableInput(bFlag);
2477 aVScrollTop->EnableInput(bFlag);
2478
2479 // from here on dynamically created ones
2480
2481 if(pTabControl!=nullptr) pTabControl->EnableInput(bFlag);
2482
2483 for (auto& p : pGridWin)
2484 if (p)
2485 p->EnableInput(bFlag, false);
2486 for (auto& p : pColBar)
2487 if (p)
2488 p->EnableInput(bFlag, false);
2489 for (auto& p : pRowBar)
2490 if (p)
2491 p->EnableInput(bFlag, false);
2492 }
2493
2494 void ScTabView::EnableAutoSpell( bool bEnable )
2495 {
2496 const bool bWasEnabled = IsAutoSpell();
2497 if (bEnable)
2498 mpSpellCheckCxt =
2499 std::make_shared<sc::SpellCheckContext>(&aViewData.GetDocument(),
2500 aViewData.GetTabNo());
2501 else
2502 mpSpellCheckCxt.reset();
2503
2504 for (VclPtr<ScGridWindow> & pWin : pGridWin)
2505 {
2506 if (!pWin)
2507 continue;
2508
2509 pWin->SetAutoSpellContext(mpSpellCheckCxt);
2510 }
2511
2512 if (bWasEnabled != bEnable && comphelper::LibreOfficeKit::isActive())
2513 {
2514 if (ScTabViewShell* pViewSh = aViewData.GetViewShell())
2515 {
2516 ScModelObj* pModel = comphelper::getFromUnoTunnel<ScModelObj>(pViewSh->GetCurrentDocument());
2517 SfxLokHelper::notifyViewRenderState(pViewSh, pModel);
2518 }
2519 }
2520 }
2521
2522 bool ScTabView::IsAutoSpell() const
2523 {
2524 return static_cast<bool>(mpSpellCheckCxt);
2525 }
2526
2527 void ScTabView::ResetAutoSpell()
2528 {
2529 for (VclPtr<ScGridWindow> & pWin : pGridWin)
2530 {
2531 if (!pWin)
2532 continue;
2533
2534 pWin->ResetAutoSpell();
2535 }
2536 }
2537
2538 void ScTabView::ResetAutoSpellForContentChange()
2539 {
2540 for (VclPtr<ScGridWindow> & pWin : pGridWin)
2541 {
2542 if (!pWin)
2543 continue;
2544
2545 pWin->ResetAutoSpellForContentChange();
2546 }
2547 }
2548
2549 void ScTabView::SetAutoSpellData( SCCOL nPosX, SCROW nPosY, const std::vector<editeng::MisspellRanges>* pRanges )
2550 {
2551 for (VclPtr<ScGridWindow> & pWin: pGridWin)
2552 {
2553 if (!pWin)
2554 continue;
2555
2556 pWin->SetAutoSpellData(nPosX, nPosY, pRanges);
2557 }
2558 }
2559
2560 namespace
2561 {
2562
2563 tools::Long lcl_GetRowHeightPx(const ScViewData &rViewData, SCROW nRow, SCTAB nTab)
2564 {
2565 const sal_uInt16 nSize = rViewData.GetDocument().GetRowHeight(nRow, nTab);
2566 return ScViewData::ToPixel(nSize, rViewData.GetPPTY());
2567 }
2568
2569 tools::Long lcl_GetColWidthPx(const ScViewData &rViewData, SCCOL nCol, SCTAB nTab)
2570 {
2571 const sal_uInt16 nSize = rViewData.GetDocument().GetColWidth(nCol, nTab);
2572 return ScViewData::ToPixel(nSize, rViewData.GetPPTX());
2573 }
2574
2575 void lcl_getGroupIndexes(const ScOutlineArray& rArray, SCCOLROW nStart, SCCOLROW nEnd, std::vector<size_t>& rGroupIndexes)
2576 {
2577 rGroupIndexes.clear();
2578 const size_t nGroupDepth = rArray.GetDepth();
2579 rGroupIndexes.resize(nGroupDepth);
2580
2581 // Get first group per each level
2582 for (size_t nLevel = 0; nLevel < nGroupDepth; ++nLevel)
2583 {
2584 if (rArray.GetCount(nLevel))
2585 {
2586 // look for a group inside the [nStartRow+1, nEndRow] range
2587 size_t nIndex;
2588 bool bFound = rArray.GetEntryIndexInRange(nLevel, nStart + 1, nEnd, nIndex);
2589 if (bFound)
2590 {
2591 if (nIndex > 0)
2592 {
2593 // is there a previous group not inside the range
2594 // but anyway intersecting it ?
2595 const ScOutlineEntry* pPrevEntry = rArray.GetEntry(nLevel, nIndex - 1);
2596 if (pPrevEntry && nStart < pPrevEntry->GetEnd())
2597 {
2598 --nIndex;
2599 }
2600 }
2601 }
2602 else
2603 {
2604 // look for a group which contains nStartRow+1
2605 bFound = rArray.GetEntryIndex(nLevel, nStart + 1, nIndex);
2606 if (!bFound)
2607 {
2608 // look for a group which contains nEndRow
2609 bFound = rArray.GetEntryIndex(nLevel, nEnd, nIndex);
2610 }
2611 }
2612
2613 if (bFound)
2614 {
2615 // skip groups with no visible control
2616 bFound = false;
2617 while (nIndex < rArray.GetCount(nLevel))
2618 {
2619 const ScOutlineEntry* pEntry = rArray.GetEntry(nLevel, nIndex);
2620 if (pEntry && pEntry->IsVisible())
2621 {
2622 bFound = true;
2623 break;
2624 }
2625 if (pEntry && pEntry->GetStart() > nEnd)
2626 {
2627 break;
2628 }
2629 ++nIndex;
2630 }
2631 }
2632
2633 rGroupIndexes[nLevel] = bFound ? nIndex : -1;
2634 }
2635 }
2636 }
2637
2638 void lcl_createGroupsData(
2639 SCCOLROW nHeaderIndex, SCCOLROW nEnd, tools::Long nSizePx, tools::Long nTotalPx,
2640 const ScOutlineArray& rArray, std::vector<size_t>& rGroupIndexes,
2641 std::vector<tools::Long>& rGroupStartPositions, OStringBuffer& rGroupsBuffer)
2642 {
2643 const size_t nGroupDepth = rArray.GetDepth();
2644 // create string data for group controls
2645 for (size_t nLevel = nGroupDepth - 1; nLevel != size_t(-1); --nLevel)
2646 {
2647 size_t nIndex = rGroupIndexes[nLevel];
2648 if (nIndex == size_t(-1))
2649 continue;
2650 const ScOutlineEntry* pEntry = rArray.GetEntry(nLevel, nIndex);
2651 if (pEntry)
2652 {
2653 if (nHeaderIndex < pEntry->GetStart())
2654 {
2655 continue;
2656 }
2657 else if (nHeaderIndex == pEntry->GetStart())
2658 {
2659 rGroupStartPositions[nLevel] = nTotalPx - nSizePx;
2660 }
2661 else if (nHeaderIndex > pEntry->GetStart() && (nHeaderIndex < nEnd && nHeaderIndex < pEntry->GetEnd()))
2662 {
2663 // for handling group started before the current view range
2664 if (rGroupStartPositions[nLevel] < 0)
2665 rGroupStartPositions[nLevel] *= -1;
2666 break;
2667 }
2668 if (nHeaderIndex == pEntry->GetEnd() || (nHeaderIndex == nEnd && rGroupStartPositions[nLevel] != -1))
2669 {
2670 // nHeaderIndex is the end col/row of a group or is the last col/row and a group started and not yet ended
2671
2672 // append a new group control data
2673 auto len = rGroupsBuffer.getLength();
2674 if (len && rGroupsBuffer[len-1] == '}')
2675 {
2676 rGroupsBuffer.append(", ");
2677 }
2678
2679 bool bGroupHidden = pEntry->IsHidden();
2680
2681 rGroupsBuffer.append(
2682 "{ \"level\": " + OString::number(nLevel + 1) + ", "
2683 "\"index\": " + OString::number(nIndex) + ", "
2684 "\"startPos\": " + OString::number(rGroupStartPositions[nLevel]) + ", "
2685 "\"endPos\": " + OString::number(nTotalPx) + ", "
2686 "\"hidden\": " + OString::number(bGroupHidden ? 1 : 0) + " }");
2687
2688 // look for the next visible group control at level nLevel
2689 bool bFound = false;
2690 ++nIndex;
2691 while (nIndex < rArray.GetCount(nLevel))
2692 {
2693 pEntry = rArray.GetEntry(nLevel, nIndex);
2694 if (pEntry && pEntry->IsVisible())
2695 {
2696 bFound = true;
2697 break;
2698 }
2699 if (pEntry && pEntry->GetStart() > nEnd)
2700 {
2701 break;
2702 }
2703 ++nIndex;
2704 }
2705 rGroupIndexes[nLevel] = bFound ? nIndex : -1;
2706 rGroupStartPositions[nLevel] = -1;
2707 }
2708 }
2709 }
2710 }
2711
2712 class ScRangeProvider
2713 {
2714 public:
2715 ScRangeProvider(const tools::Rectangle& rArea, bool bInPixels,
2716 ScViewData& rViewData):
2717 mrViewData(rViewData)
2718 {
2719 tools::Rectangle aAreaPx = bInPixels ? rArea :
2720 tools::Rectangle(rArea.Left() * mrViewData.GetPPTX(),
2721 rArea.Top() * mrViewData.GetPPTY(),
2722 rArea.Right() * mrViewData.GetPPTX(),
2723 rArea.Bottom() * mrViewData.GetPPTY());
2724 calculateBounds(aAreaPx);
2725 }
2726
2727 const ScRange& getCellRange() const
2728 {
2729 return maRange;
2730 }
2731
2732 void getColPositions(tools::Long& rStartColPos, tools::Long& rEndColPos) const
2733 {
2734 rStartColPos = maBoundPositions.Left();
2735 rEndColPos = maBoundPositions.Right();
2736 }
2737
2738 void getRowPositions(tools::Long& rStartRowPos, tools::Long& rEndRowPos) const
2739 {
2740 rStartRowPos = maBoundPositions.Top();
2741 rEndRowPos = maBoundPositions.Bottom();
2742 }
2743
2744 private:
2745 void calculateBounds(const tools::Rectangle& rAreaPx)
2746 {
2747 tools::Long nLeftPx = 0, nRightPx = 0;
2748 SCCOLROW nStartCol = -1, nEndCol = -1;
2749 calculateDimensionBounds(rAreaPx.Left(), rAreaPx.Right(), true,
2750 nStartCol, nEndCol, nLeftPx, nRightPx,
2751 mnEnlargeX, mrViewData);
2752 tools::Long nTopPx = 0, nBottomPx = 0;
2753 SCCOLROW nStartRow = -1, nEndRow = -1;
2754 calculateDimensionBounds(rAreaPx.Top(), rAreaPx.Bottom(), false,
2755 nStartRow, nEndRow, nTopPx, nBottomPx,
2756 mnEnlargeY, mrViewData);
2757
2758 maRange.aStart.Set(nStartCol, nStartRow, mrViewData.GetTabNo());
2759 maRange.aEnd.Set(nEndCol, nEndRow, mrViewData.GetTabNo());
2760
2761 maBoundPositions.SetLeft(nLeftPx);
2762 maBoundPositions.SetRight(nRightPx);
2763 maBoundPositions.SetTop(nTopPx);
2764 maBoundPositions.SetBottom(nBottomPx);
2765 }
2766
2767 // All positions are in pixels.
2768 static void calculateDimensionBounds(const tools::Long nStartPos, const tools::Long nEndPos,
2769 bool bColumns, SCCOLROW& rStartIndex,
2770 SCCOLROW& rEndIndex, tools::Long& rBoundStart,
2771 tools::Long& rBoundEnd, SCCOLROW nEnlarge,
2772 ScViewData& rViewData)
2773 {
2774 ScPositionHelper& rPosHelper = bColumns ? rViewData.GetLOKWidthHelper() :
2775 rViewData.GetLOKHeightHelper();
2776 const auto& rStartNearest = rPosHelper.getNearestByPosition(nStartPos);
2777 const auto& rEndNearest = rPosHelper.getNearestByPosition(nEndPos);
2778
2779 ScBoundsProvider aBoundsProvider(rViewData, rViewData.GetTabNo(), bColumns);
2780 aBoundsProvider.Compute(rStartNearest, rEndNearest, nStartPos, nEndPos);
2781 aBoundsProvider.EnlargeBy(nEnlarge);
2782 if (bColumns)
2783 {
2784 SCCOL nStartCol = -1, nEndCol = -1;
2785 aBoundsProvider.GetStartIndexAndPosition(nStartCol, rBoundStart);
2786 aBoundsProvider.GetEndIndexAndPosition(nEndCol, rBoundEnd);
2787 rStartIndex = nStartCol;
2788 rEndIndex = nEndCol;
2789 }
2790 else
2791 {
2792 SCROW nStartRow = -1, nEndRow = -1;
2793 aBoundsProvider.GetStartIndexAndPosition(nStartRow, rBoundStart);
2794 aBoundsProvider.GetEndIndexAndPosition(nEndRow, rBoundEnd);
2795 rStartIndex = nStartRow;
2796 rEndIndex = nEndRow;
2797 }
2798 }
2799
2800 private:
2801
2802 ScRange maRange;
2803 tools::Rectangle maBoundPositions;
2804 ScViewData& mrViewData;
2805 static const SCCOLROW mnEnlargeX = 2;
2806 static const SCCOLROW mnEnlargeY = 2;
2807 };
2808
2809 void lcl_ExtendTiledDimension(bool bColumn, const SCCOLROW nEnd, const SCCOLROW nExtra,
2810 ScTabView& rTabView, ScViewData& rViewData)
2811 {
2812 ScDocument& rDoc = rViewData.GetDocument();
2813 // If we are approaching current max tiled row/col, signal a size changed event
2814 // and invalidate the involved area
2815 SCCOLROW nMaxTiledIndex = bColumn ? rViewData.GetMaxTiledCol() : rViewData.GetMaxTiledRow();
2816 SCCOLROW nHardLimit = !bColumn ? MAXTILEDROW : rDoc.MaxCol();
2817
2818 if (nMaxTiledIndex >= nHardLimit)
2819 return;
2820
2821 if (nEnd <= nMaxTiledIndex - nExtra) // No need to extend.
2822 return;
2823
2824 ScDocShell* pDocSh = rViewData.GetDocShell();
2825 ScModelObj* pModelObj = pDocSh ? pDocSh->GetModel() : nullptr;
2826 Size aOldSize(0, 0);
2827 if (pModelObj)
2828 aOldSize = pModelObj->getDocumentSize();
2829
2830 SCCOLROW nNewMaxTiledIndex = std::min(std::max(nEnd, nMaxTiledIndex) + nExtra, nHardLimit);
2831
2832 if (bColumn)
2833 rViewData.SetMaxTiledCol(nNewMaxTiledIndex);
2834 else
2835 rViewData.SetMaxTiledRow(nNewMaxTiledIndex);
2836
2837 Size aNewSize(0, 0);
2838 if (pModelObj)
2839 aNewSize = pModelObj->getDocumentSize();
2840
2841 if (!pDocSh)
2842 return;
2843
2844 if (pModelObj)
2845 {
2846 ScGridWindow* pGridWindow = rViewData.GetActiveWin();
2847 if (pGridWindow)
2848 {
2849 Size aNewSizePx(aNewSize.Width() * rViewData.GetPPTX(), aNewSize.Height() * rViewData.GetPPTY());
2850 if (aNewSizePx != pGridWindow->GetOutputSizePixel())
2851 pGridWindow->SetOutputSizePixel(aNewSizePx);
2852 }
2853 }
2854
2855 if (aOldSize == aNewSize)
2856 return;
2857
2858 // New area extended to the right/bottom of the sheet after last col/row
2859 tools::Rectangle aNewArea(Point(0, 0), aNewSize);
2860 // excluding overlapping area with aNewArea
2861 if (bColumn)
2862 aNewArea.SetLeft(aOldSize.getWidth());
2863 else
2864 aNewArea.SetTop(aOldSize.getHeight());
2865
2866 // Only invalidate if spreadsheet has extended to the right or bottom
2867 if ((bColumn && aNewArea.getOpenWidth()) || (!bColumn && aNewArea.getOpenHeight()))
2868 {
2869 rTabView.UpdateSelectionOverlay();
2870 SfxLokHelper::notifyInvalidation(rViewData.GetViewShell(), &aNewArea);
2871 }
2872
2873 // Provide size in the payload, so clients don't have to query for that.
2874 std::stringstream ss;
2875 ss << aNewSize.Width() << ", " << aNewSize.Height();
2876 OString sSize( ss.str() );
2877 ScModelObj* pModel = comphelper::getFromUnoTunnel<ScModelObj>(
2878 rViewData.GetViewShell()->GetCurrentDocument());
2879 SfxLokHelper::notifyDocumentSizeChanged(rViewData.GetViewShell(), sSize, pModel, false);
2880 }
2881
2882 } // anonymous namespace
2883
2884 void ScTabView::getRowColumnHeaders(const tools::Rectangle& rRectangle, tools::JsonWriter& rJsonWriter)
2885 {
2886 ScDocument& rDoc = aViewData.GetDocument();
2887
2888 if (rRectangle.IsEmpty())
2889 return;
2890
2891 bool bRangeHeaderSupport = comphelper::LibreOfficeKit::isRangeHeaders();
2892
2893 rJsonWriter.put("commandName", ".uno:ViewRowColumnHeaders");
2894
2895 SCTAB nTab = aViewData.GetTabNo();
2896 SCROW nStartRow = -1;
2897 SCROW nEndRow = -1;
2898 tools::Long nStartHeightPx = 0;
2899 SCCOL nStartCol = -1;
2900 SCCOL nEndCol = -1;
2901 tools::Long nStartWidthPx = 0;
2902
2903 tools::Rectangle aOldVisArea(
2904 mnLOKStartHeaderCol + 1, mnLOKStartHeaderRow + 1,
2905 mnLOKEndHeaderCol, mnLOKEndHeaderRow);
2906
2907 ScRangeProvider aRangeProvider(rRectangle, /* bInPixels */ false, aViewData);
2908 const ScRange& rCellRange = aRangeProvider.getCellRange();
2909
2910 /// *** start collecting ROWS ***
2911
2912 /// 1) compute start and end rows
2913
2914 if (rRectangle.Top() < rRectangle.Bottom())
2915 {
2916 SAL_INFO("sc.lok.header", "Row Header: compute start/end rows.");
2917 tools::Long nEndHeightPx = 0;
2918 nStartRow = rCellRange.aStart.Row();
2919 nEndRow = rCellRange.aEnd.Row();
2920 aRangeProvider.getRowPositions(nStartHeightPx, nEndHeightPx);
2921
2922 aViewData.GetLOKHeightHelper().removeByIndex(mnLOKStartHeaderRow);
2923 aViewData.GetLOKHeightHelper().removeByIndex(mnLOKEndHeaderRow);
2924 aViewData.GetLOKHeightHelper().insert(nStartRow, nStartHeightPx);
2925 aViewData.GetLOKHeightHelper().insert(nEndRow, nEndHeightPx);
2926
2927 mnLOKStartHeaderRow = nStartRow;
2928 mnLOKEndHeaderRow = nEndRow;
2929 }
2930
2931 sal_Int32 nVisibleRows = nEndRow - nStartRow;
2932 if (nVisibleRows < 25)
2933 nVisibleRows = 25;
2934
2935 SAL_INFO("sc.lok.header", "Row Header: visible rows: " << nVisibleRows);
2936
2937
2938 // Get row groups
2939 // per each level store the index of the first group intersecting
2940 // [nStartRow, nEndRow] range
2941
2942 const ScOutlineTable* pTable = rDoc.GetOutlineTable(nTab);
2943 const ScOutlineArray* pRowArray = pTable ? &(pTable->GetRowArray()) : nullptr;
2944 size_t nRowGroupDepth = 0;
2945 std::vector<size_t> aRowGroupIndexes;
2946 if (bRangeHeaderSupport && pTable)
2947 {
2948 nRowGroupDepth = pRowArray->GetDepth();
2949 lcl_getGroupIndexes(*pRowArray, nStartRow, nEndRow, aRowGroupIndexes);
2950 }
2951
2952 /// 2) if we are approaching current max tiled row, signal a size changed event
2953 /// and invalidate the involved area
2954 lcl_ExtendTiledDimension(/* bColumn */ false, nEndRow, nVisibleRows, *this, aViewData);
2955
2956 /// 3) create string data for rows
2957
2958 tools::Long nTotalPixels = nStartHeightPx;
2959 tools::Long nPrevSizePx = -1;
2960 OStringBuffer aRowGroupsBuffer = "\"rowGroups\": [\n";
2961 {
2962 auto rowsNode = rJsonWriter.startArray("rows");
2963
2964 SAL_INFO("sc.lok.header", "Row Header: [create string data for rows]: start row: "
2965 << nStartRow << " start height: " << nTotalPixels);
2966
2967 if (nStartRow != nEndRow)
2968 {
2969 auto node = rJsonWriter.startStruct();
2970 rJsonWriter.put("text", nStartRow + 1);
2971 rJsonWriter.put("size", nTotalPixels);
2972 rJsonWriter.put("groupLevels", static_cast<sal_Int64>(nRowGroupDepth));
2973 }
2974
2975 std::vector<tools::Long> aRowGroupStartPositions(nRowGroupDepth, -nTotalPixels);
2976 for (SCROW nRow = nStartRow + 1; nRow <= nEndRow; ++nRow)
2977 {
2978 // nSize will be 0 for hidden rows.
2979 const tools::Long nSizePx = lcl_GetRowHeightPx(aViewData, nRow, nTab);
2980 nTotalPixels += nSizePx;
2981
2982 if (bRangeHeaderSupport && nRowGroupDepth > 0)
2983 {
2984 lcl_createGroupsData(nRow, nEndRow, nSizePx, nTotalPixels,
2985 *pRowArray, aRowGroupIndexes, aRowGroupStartPositions,
2986 aRowGroupsBuffer);
2987 }
2988
2989 if (bRangeHeaderSupport && nRow < nEndRow && nSizePx == nPrevSizePx)
2990 continue;
2991 nPrevSizePx = nSizePx;
2992
2993 auto node = rJsonWriter.startStruct();
2994 rJsonWriter.put("text", pRowBar[SC_SPLIT_BOTTOM]->GetEntryText(nRow));
2995 rJsonWriter.put("size", nTotalPixels);
2996 }
2997
2998 aRowGroupsBuffer.append("]");
2999 }
3000 if (nRowGroupDepth > 0)
3001 {
3002 aRowGroupsBuffer.append(",\n");
3003 rJsonWriter.putRaw(aRowGroupsBuffer);
3004 }
3005 /// end collecting ROWS
3006
3007
3008 /// *** start collecting COLS ***
3009
3010 /// 1) compute start and end columns
3011
3012 if (rRectangle.Left() < rRectangle.Right())
3013 {
3014 SAL_INFO("sc.lok.header", "Column Header: compute start/end columns.");
3015 tools::Long nEndWidthPx = 0;
3016 nStartCol = rCellRange.aStart.Col();
3017 nEndCol = rCellRange.aEnd.Col();
3018 aRangeProvider.getColPositions(nStartWidthPx, nEndWidthPx);
3019
3020 aViewData.GetLOKWidthHelper().removeByIndex(mnLOKStartHeaderCol);
3021 aViewData.GetLOKWidthHelper().removeByIndex(mnLOKEndHeaderCol);
3022 aViewData.GetLOKWidthHelper().insert(nStartCol, nStartWidthPx);
3023 aViewData.GetLOKWidthHelper().insert(nEndCol, nEndWidthPx);
3024
3025 mnLOKStartHeaderCol = nStartCol;
3026 mnLOKEndHeaderCol = nEndCol;
3027 }
3028
3029 sal_Int32 nVisibleCols = nEndCol - nStartCol;
3030 if (nVisibleCols < 10)
3031 nVisibleCols = 10;
3032
3033
3034 // Get column groups
3035 // per each level store the index of the first group intersecting
3036 // [nStartCol, nEndCol] range
3037
3038 const ScOutlineArray* pColArray = pTable ? &(pTable->GetColArray()) : nullptr;
3039 size_t nColGroupDepth = 0;
3040 std::vector<size_t> aColGroupIndexes;
3041 if (bRangeHeaderSupport && pTable)
3042 {
3043 nColGroupDepth = pColArray->GetDepth();
3044 lcl_getGroupIndexes(*pColArray, nStartCol, nEndCol, aColGroupIndexes);
3045 }
3046
3047 /// 2) if we are approaching current max tiled column, signal a size changed event
3048 /// and invalidate the involved area
3049 lcl_ExtendTiledDimension(/* bColumn */ true, nEndCol, nVisibleCols, *this, aViewData);
3050
3051 /// 3) create string data for columns
3052 OStringBuffer aColGroupsBuffer = "\"columnGroups\": [\n";
3053 {
3054 auto columnsNode = rJsonWriter.startArray("columns");
3055
3056 nTotalPixels = nStartWidthPx;
3057 SAL_INFO("sc.lok.header", "Col Header: [create string data for cols]: start col: "
3058 << nStartRow << " start width: " << nTotalPixels);
3059
3060 if (nStartCol != nEndCol)
3061 {
3062 auto node = rJsonWriter.startStruct();
3063 rJsonWriter.put("text", static_cast<sal_Int64>(nStartCol) + 1);
3064 rJsonWriter.put("size", nTotalPixels);
3065 rJsonWriter.put("groupLevels", static_cast<sal_Int64>(nColGroupDepth));
3066 }
3067
3068 std::vector<tools::Long> aColGroupStartPositions(nColGroupDepth, -nTotalPixels);
3069 nPrevSizePx = -1;
3070 for (SCCOL nCol = nStartCol + 1; nCol <= nEndCol; ++nCol)
3071 {
3072 // nSize will be 0 for hidden columns.
3073 const tools::Long nSizePx = lcl_GetColWidthPx(aViewData, nCol, nTab);
3074 nTotalPixels += nSizePx;
3075
3076 if (bRangeHeaderSupport && nColGroupDepth > 0)
3077 lcl_createGroupsData(nCol, nEndCol, nSizePx, nTotalPixels,
3078 *pColArray, aColGroupIndexes,
3079 aColGroupStartPositions, aColGroupsBuffer);
3080
3081 if (bRangeHeaderSupport && nCol < nEndCol && nSizePx == nPrevSizePx)
3082 continue;
3083 nPrevSizePx = nSizePx;
3084
3085 OUString aText = bRangeHeaderSupport ?
3086 OUString::number(nCol + 1) : pColBar[SC_SPLIT_LEFT]->GetEntryText(nCol);
3087
3088 auto node = rJsonWriter.startStruct();
3089 rJsonWriter.put("text", aText);
3090 rJsonWriter.put("size", nTotalPixels);
3091 }
3092
3093 aColGroupsBuffer.append("]");
3094 }
3095 if (nColGroupDepth > 0)
3096 {
3097 aColGroupsBuffer.append(",\n");
3098 rJsonWriter.putRaw(aColGroupsBuffer);
3099 }
3100 /// end collecting COLs
3101
3102 vcl::Region aNewVisArea(
3103 tools::Rectangle(mnLOKStartHeaderCol + 1, mnLOKStartHeaderRow + 1,
3104 mnLOKEndHeaderCol, mnLOKEndHeaderRow));
3105 aNewVisArea.Exclude(aOldVisArea);
3106 tools::Rectangle aChangedArea = aNewVisArea.GetBoundRect();
3107 if (!aChangedArea.IsEmpty())
3108 {
3109 UpdateVisibleRange();
3110 UpdateFormulas(aChangedArea.Left(), aChangedArea.Top(), aChangedArea.Right(), aChangedArea.Bottom());
3111 }
3112 }
3113
3114 OString ScTabView::getSheetGeometryData(bool bColumns, bool bRows, bool bSizes, bool bHidden,
3115 bool bFiltered, bool bGroups)
3116 {
3117 ScDocument& rDoc = aViewData.GetDocument();
3118
3119 boost::property_tree::ptree aTree;
3120 aTree.put("commandName", ".uno:SheetGeometryData");
3121 aTree.put("maxtiledcolumn", rDoc.MaxCol());
3122 aTree.put("maxtiledrow", MAXTILEDROW);
3123
3124 auto getJSONString = [](const boost::property_tree::ptree& rTree) {
3125 std::stringstream aStream;
3126 boost::property_tree::write_json(aStream, rTree);
3127 return aStream.str();
3128 };
3129
3130 if ((!bSizes && !bHidden && !bFiltered && !bGroups) ||
3131 (!bColumns && !bRows))
3132 {
3133 return OString(getJSONString(aTree));
3134 }
3135
3136 struct GeomEntry
3137 {
3138 SheetGeomType eType;
3139 const char* pKey;
3140 bool bEnabled;
3141 };
3142
3143 const GeomEntry aGeomEntries[] = {
3144 { SheetGeomType::SIZES, "sizes", bSizes },
3145 { SheetGeomType::HIDDEN, "hidden", bHidden },
3146 { SheetGeomType::FILTERED, "filtered", bFiltered },
3147 { SheetGeomType::GROUPS, "groups", bGroups }
3148 };
3149
3150 struct DimensionEntry
3151 {
3152 const char* pKey;
3153 bool bDimIsCol;
3154 bool bEnabled;
3155 };
3156
3157 const DimensionEntry aDimEntries[] = {
3158 { "columns", true, bColumns },
3159 { "rows", false, bRows }
3160 };
3161
3162 SCTAB nTab = aViewData.GetTabNo();
3163
3164 for (const auto& rDimEntry : aDimEntries)
3165 {
3166 if (!rDimEntry.bEnabled)
3167 continue;
3168
3169 bool bDimIsCol = rDimEntry.bDimIsCol;
3170
3171 boost::property_tree::ptree aDimTree;
3172 for (const auto& rGeomEntry : aGeomEntries)
3173 {
3174 if (!rGeomEntry.bEnabled)
3175 continue;
3176
3177 OString aGeomDataEncoding = rDoc.dumpSheetGeomData(nTab, bDimIsCol, rGeomEntry.eType);
3178 // TODO: Investigate if we can avoid the copy of the 'value' string in put().
3179 aDimTree.put(rGeomEntry.pKey, aGeomDataEncoding.getStr());
3180 }
3181
3182 aTree.add_child(rDimEntry.pKey, aDimTree);
3183 }
3184
3185 return OString(getJSONString(aTree));
3186 }
3187
3188 void ScTabView::extendTiledAreaIfNeeded()
3189 {
3190 SAL_INFO("sc.lok.header",
3191 "extendTiledAreaIfNeeded: START: ClientView: ColRange["
3192 << mnLOKStartHeaderCol << "," << mnLOKEndHeaderCol
3193 << "] RowRange[" << mnLOKStartHeaderRow << "," << mnLOKEndHeaderRow
3194 << "] MaxTiledCol = " << aViewData.GetMaxTiledCol()
3195 << " MaxTiledRow = " << aViewData.GetMaxTiledRow());
3196
3197 const tools::Rectangle rVisArea = aViewData.getLOKVisibleArea();
3198 if (rVisArea.Top() >= rVisArea.Bottom() ||
3199 rVisArea.Left() >= rVisArea.Right())
3200 return;
3201
3202 // Needed for conditional updating of visible-range/formula.
3203 tools::Rectangle aOldVisCellRange(mnLOKStartHeaderCol + 1, mnLOKStartHeaderRow + 1,
3204 mnLOKEndHeaderCol, mnLOKEndHeaderRow);
3205
3206 ScRangeProvider aRangeProvider(rVisArea, /* bInPixels */ false, aViewData);
3207 // Index bounds.
3208 const ScRange& rCellRange = aRangeProvider.getCellRange();
3209 const SCCOL nStartCol = rCellRange.aStart.Col();
3210 const SCCOL nEndCol = rCellRange.aEnd.Col();
3211 const SCROW nStartRow = rCellRange.aStart.Row();
3212 const SCROW nEndRow = rCellRange.aEnd.Row();
3213
3214 // Column/Row positions.
3215 tools::Long nStartColPos, nEndColPos, nStartRowPos, nEndRowPos;
3216 aRangeProvider.getColPositions(nStartColPos, nEndColPos);
3217 aRangeProvider.getRowPositions(nStartRowPos, nEndRowPos);
3218
3219 ScPositionHelper& rWidthHelper = aViewData.GetLOKWidthHelper();
3220 ScPositionHelper& rHeightHelper = aViewData.GetLOKHeightHelper();
3221
3222 // Update mnLOKStartHeaderCol and mnLOKEndHeaderCol members.
3223 // These are consulted in some ScGridWindow methods.
3224 if (mnLOKStartHeaderCol != nStartCol)
3225 {
3226 rWidthHelper.removeByIndex(mnLOKStartHeaderCol);
3227 rWidthHelper.insert(nStartCol, nStartColPos);
3228 mnLOKStartHeaderCol = nStartCol;
3229 }
3230
3231 if (mnLOKEndHeaderCol != nEndCol)
3232 {
3233 rWidthHelper.removeByIndex(mnLOKEndHeaderCol);
3234 rWidthHelper.insert(nEndCol, nEndColPos);
3235 mnLOKEndHeaderCol = nEndCol;
3236 }
3237
3238 // Update mnLOKStartHeaderRow and mnLOKEndHeaderRow members.
3239 // These are consulted in some ScGridWindow methods.
3240 if (mnLOKStartHeaderRow != nStartRow)
3241 {
3242 rHeightHelper.removeByIndex(mnLOKStartHeaderRow);
3243 rHeightHelper.insert(nStartRow, nStartRowPos);
3244 mnLOKStartHeaderRow = nStartRow;
3245 }
3246
3247 if (mnLOKEndHeaderRow != nEndRow)
3248 {
3249 rHeightHelper.removeByIndex(mnLOKEndHeaderRow);
3250 rHeightHelper.insert(nEndRow, nEndRowPos);
3251 mnLOKEndHeaderRow = nEndRow;
3252 }
3253
3254 constexpr SCCOL nMinExtraCols = 10;
3255 SCCOL nExtraCols = std::max<SCCOL>(nMinExtraCols, nEndCol - nStartCol);
3256 // If we are approaching current max tiled column, signal a size changed event
3257 // and invalidate the involved area.
3258 lcl_ExtendTiledDimension(/* bColumn */ true, nEndCol, nExtraCols, *this, aViewData);
3259
3260 constexpr SCROW nMinExtraRows = 25;
3261 SCROW nExtraRows = std::max(nMinExtraRows, nEndRow - nStartRow);
3262 // If we are approaching current max tiled row, signal a size changed event
3263 // and invalidate the involved area.
3264 lcl_ExtendTiledDimension(/* bColumn */ false, nEndRow, nExtraRows, *this, aViewData);
3265
3266 vcl::Region aNewVisCellRange(
3267 tools::Rectangle(mnLOKStartHeaderCol + 1, mnLOKStartHeaderRow + 1,
3268 mnLOKEndHeaderCol, mnLOKEndHeaderRow));
3269 aNewVisCellRange.Exclude(aOldVisCellRange);
3270 tools::Rectangle aChangedCellRange = aNewVisCellRange.GetBoundRect();
3271 if (!aChangedCellRange.IsEmpty())
3272 {
3273 UpdateVisibleRange();
3274 UpdateFormulas(aChangedCellRange.Left(), aChangedCellRange.Top(),
3275 aChangedCellRange.Right(), aChangedCellRange.Bottom());
3276 }
3277
3278 SAL_INFO("sc.lok.header",
3279 "extendTiledAreaIfNeeded: END: ClientView: ColRange["
3280 << mnLOKStartHeaderCol << "," << mnLOKEndHeaderCol
3281 << "] RowRange[" << mnLOKStartHeaderRow << "," << mnLOKEndHeaderRow
3282 << "] MaxTiledCol = " << aViewData.GetMaxTiledCol()
3283 << " MaxTiledRow = " << aViewData.GetMaxTiledRow());
3284 }
3285
3286 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE