Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #include <vcl/svapp.hxx>
21 :
22 : #include "scitems.hxx"
23 : #include <sfx2/viewfrm.hxx>
24 : #include <sfx2/bindings.hxx>
25 : #include <vcl/help.hxx>
26 : #include <vcl/settings.hxx>
27 :
28 : #include "tabview.hxx"
29 : #include "tabvwsh.hxx"
30 : #include "document.hxx"
31 : #include "gridwin.hxx"
32 : #include "olinewin.hxx"
33 : #include "olinetab.hxx"
34 : #include "tabsplit.hxx"
35 : #include "colrowba.hxx"
36 : #include "tabcont.hxx"
37 : #include "scmod.hxx"
38 : #include "sc.hrc"
39 : #include "viewutil.hxx"
40 : #include "globstr.hrc"
41 : #include "drawview.hxx"
42 : #include "docsh.hxx"
43 : #include "viewuno.hxx"
44 : #include "AccessibilityHints.hxx"
45 : #include "appoptio.hxx"
46 : #include "attrib.hxx"
47 : #include "hintwin.hxx"
48 :
49 : #include <com/sun/star/sheet/DataPilotFieldOrientation.hpp>
50 :
51 : #include <string>
52 : #include <algorithm>
53 :
54 : #include <basegfx/tools/zoomtools.hxx>
55 :
56 : #define SPLIT_MARGIN 30
57 : #define SPLIT_HANDLE_SIZE 5
58 : #define SC_ICONSIZE 36
59 :
60 : #define SC_SCROLLBAR_MIN 30
61 : #define SC_TABBAR_MIN 6
62 :
63 : using namespace ::com::sun::star;
64 :
65 : // Corner-Button
66 :
67 0 : ScCornerButton::ScCornerButton( Window* pParent, ScViewData* pData, bool bAdditional ) :
68 : Window( pParent, WinBits( 0 ) ),
69 : pViewData( pData ),
70 0 : bAdd( bAdditional )
71 : {
72 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
73 0 : SetBackground( rStyleSettings.GetFaceColor() );
74 0 : EnableRTL( false );
75 0 : }
76 :
77 0 : ScCornerButton::~ScCornerButton()
78 : {
79 0 : }
80 :
81 0 : void ScCornerButton::Paint( const Rectangle& rRect )
82 : {
83 0 : Size aSize = GetOutputSizePixel();
84 0 : long nPosX = aSize.Width()-1;
85 0 : long nPosY = aSize.Height()-1;
86 :
87 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
88 :
89 0 : Window::Paint(rRect);
90 :
91 0 : bool bLayoutRTL = pViewData->GetDocument()->IsLayoutRTL( pViewData->GetTabNo() );
92 0 : long nDarkX = bLayoutRTL ? 0 : nPosX;
93 :
94 0 : if ( !bAdd )
95 : {
96 : // match the shaded look of column/row headers
97 :
98 0 : Color aFace( rStyleSettings.GetFaceColor() );
99 0 : Color aWhite( COL_WHITE );
100 0 : Color aCenter( aFace );
101 0 : aCenter.Merge( aWhite, 0xd0 ); // lighten up a bit
102 0 : Color aOuter( aFace );
103 0 : aOuter.Merge( aWhite, 0xa0 ); // lighten up more
104 :
105 0 : long nCenterX = (aSize.Width() / 2) - 1;
106 0 : long nCenterY = (aSize.Height() / 2) - 1;
107 :
108 0 : SetLineColor();
109 0 : SetFillColor(aCenter);
110 0 : DrawRect( Rectangle( nCenterX, nCenterY, nCenterX, nPosY ) );
111 0 : DrawRect( Rectangle( nCenterX, nCenterY, nDarkX, nCenterY ) );
112 0 : SetFillColor(aOuter);
113 0 : DrawRect( Rectangle( 0, 0, nPosX, nCenterY-1 ) );
114 0 : if ( bLayoutRTL )
115 0 : DrawRect( Rectangle( nCenterX+1, nCenterY, nPosX, nPosY ) );
116 : else
117 0 : DrawRect( Rectangle( 0, nCenterY, nCenterX-1, nPosY ) );
118 : }
119 :
120 : // both buttons have the same look now - only dark right/bottom lines
121 0 : SetLineColor( rStyleSettings.GetDarkShadowColor() );
122 0 : DrawLine( Point(0,nPosY), Point(nPosX,nPosY) );
123 0 : DrawLine( Point(nDarkX,0), Point(nDarkX,nPosY) );
124 0 : }
125 :
126 0 : void ScCornerButton::StateChanged( StateChangedType nType )
127 : {
128 0 : Window::StateChanged( nType );
129 :
130 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
131 0 : SetBackground( rStyleSettings.GetFaceColor() );
132 0 : Invalidate();
133 0 : }
134 :
135 0 : void ScCornerButton::DataChanged( const DataChangedEvent& rDCEvt )
136 : {
137 0 : Window::DataChanged( rDCEvt );
138 :
139 0 : const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
140 0 : SetBackground( rStyleSettings.GetFaceColor() );
141 0 : Invalidate();
142 0 : }
143 :
144 :
145 0 : void ScCornerButton::Resize()
146 : {
147 0 : Invalidate();
148 0 : }
149 :
150 0 : void ScCornerButton::MouseButtonDown( const MouseEvent& rMEvt )
151 : {
152 0 : ScModule* pScMod = SC_MOD();
153 0 : bool bDisable = pScMod->IsFormulaMode() || pScMod->IsModalMode();
154 0 : if (!bDisable)
155 : {
156 0 : ScTabViewShell* pViewSh = pViewData->GetViewShell();
157 0 : pViewSh->SetActive(); // Appear und SetViewFrame
158 0 : pViewSh->ActiveGrabFocus();
159 :
160 0 : bool bControl = rMEvt.IsMod1();
161 0 : pViewSh->SelectAll( bControl );
162 : }
163 0 : }
164 :
165 0 : static bool lcl_HasColOutline( const ScViewData& rViewData )
166 : {
167 0 : const ScOutlineTable* pTable = rViewData.GetDocument()->GetOutlineTable(rViewData.GetTabNo());
168 0 : if (pTable)
169 : {
170 0 : const ScOutlineArray* pArray = pTable->GetColArray();
171 0 : if ( pArray->GetDepth() > 0 )
172 0 : return true;
173 : }
174 0 : return false;
175 : }
176 :
177 0 : static bool lcl_HasRowOutline( const ScViewData& rViewData )
178 : {
179 0 : const ScOutlineTable* pTable = rViewData.GetDocument()->GetOutlineTable(rViewData.GetTabNo());
180 0 : if (pTable)
181 : {
182 0 : const ScOutlineArray* pArray = pTable->GetRowArray();
183 0 : if ( pArray->GetDepth() > 0 )
184 0 : return true;
185 : }
186 0 : return false;
187 : }
188 :
189 0 : ScTabView::ScTabView( Window* pParent, ScDocShell& rDocSh, ScTabViewShell* pViewShell ) :
190 : pFrameWin( pParent ),
191 : aViewData( &rDocSh, pViewShell ),
192 : pSelEngine( NULL ),
193 : aFunctionSet( &aViewData ),
194 : pHdrSelEng( NULL ),
195 : aHdrFunc( &aViewData ),
196 : pDrawView( NULL ),
197 : aVScrollTop( pFrameWin, WinBits( WB_VSCROLL | WB_DRAG ) ),
198 : aVScrollBottom( pFrameWin, WinBits( WB_VSCROLL | WB_DRAG ) ),
199 : aHScrollLeft( pFrameWin, WinBits( WB_HSCROLL | WB_DRAG ) ),
200 : aHScrollRight( pFrameWin, WinBits( WB_HSCROLL | WB_DRAG ) ),
201 : aCornerButton( pFrameWin, &aViewData, false ),
202 : aTopButton( pFrameWin, &aViewData, true ),
203 : aScrollBarBox( pFrameWin, WB_SIZEABLE ),
204 : mpInputHintWindow( NULL ),
205 : pPageBreakData( NULL ),
206 : pBrushDocument( NULL ),
207 : pDrawBrushSet( NULL ),
208 : pTimerWindow( NULL ),
209 : nTipVisible( 0 ),
210 : meBlockMode(None),
211 : mfPendingTabBarWidth( -1.0 ),
212 : bMinimized( false ),
213 : bInUpdateHeader( false ),
214 : bInActivatePart( false ),
215 : bInZoomUpdate( false ),
216 : bMoveIsShift( false ),
217 : bDrawSelMode( false ),
218 : bLockPaintBrush( false ),
219 : bDragging( false ),
220 : bBlockNeg( false ),
221 : bBlockCols( false ),
222 0 : bBlockRows( false )
223 : {
224 0 : Init();
225 0 : }
226 :
227 :
228 0 : void ScTabView::InitScrollBar( ScrollBar& rScrollBar, long nMaxVal )
229 : {
230 0 : rScrollBar.SetRange( Range( 0, nMaxVal ) );
231 0 : rScrollBar.SetLineSize( 1 );
232 0 : rScrollBar.SetPageSize( 1 ); // wird getrennt abgefragt
233 0 : rScrollBar.SetVisibleSize( 10 ); // wird bei Resize neu gesetzt
234 :
235 0 : rScrollBar.SetScrollHdl( LINK(this, ScTabView, ScrollHdl) );
236 0 : rScrollBar.SetEndScrollHdl( LINK(this, ScTabView, EndScrollHdl) );
237 :
238 0 : rScrollBar.EnableRTL( aViewData.GetDocument()->IsLayoutRTL( aViewData.GetTabNo() ) );
239 0 : }
240 :
241 : // Scroll-Timer
242 :
243 0 : void ScTabView::SetTimer( ScGridWindow* pWin, const MouseEvent& rMEvt )
244 : {
245 0 : pTimerWindow = pWin;
246 0 : aTimerMEvt = rMEvt;
247 0 : aScrollTimer.Start();
248 0 : }
249 :
250 0 : void ScTabView::ResetTimer()
251 : {
252 0 : aScrollTimer.Stop();
253 0 : pTimerWindow = NULL;
254 0 : }
255 :
256 0 : IMPL_LINK_NOARG(ScTabView, TimerHdl)
257 : {
258 0 : if (pTimerWindow)
259 0 : pTimerWindow->MouseMove( aTimerMEvt );
260 :
261 0 : return 0;
262 : }
263 :
264 : // --- Resize ---------------------------------------------------------------------
265 :
266 0 : static void lcl_SetPosSize( Window& rWindow, const Point& rPos, const Size& rSize,
267 : long nTotalWidth, bool bLayoutRTL )
268 : {
269 0 : Point aNewPos = rPos;
270 0 : if ( bLayoutRTL )
271 : {
272 0 : aNewPos.X() = nTotalWidth - rPos.X() - rSize.Width();
273 0 : if ( aNewPos == rWindow.GetPosPixel() && rSize.Width() != rWindow.GetSizePixel().Width() )
274 : {
275 : // Document windows are manually painted right-to-left, so they need to
276 : // be repainted if the size changes.
277 0 : rWindow.Invalidate();
278 : }
279 : }
280 0 : rWindow.SetPosSizePixel( aNewPos, rSize );
281 0 : }
282 :
283 0 : void ScTabView::DoResize( const Point& rOffset, const Size& rSize, bool bInner )
284 : {
285 0 : HideListBox();
286 :
287 0 : bool bHasHint = HasHintWindow();
288 0 : if (bHasHint)
289 0 : RemoveHintWindow();
290 :
291 0 : bool bLayoutRTL = aViewData.GetDocument()->IsLayoutRTL( aViewData.GetTabNo() );
292 0 : long nTotalWidth = rSize.Width();
293 0 : if ( bLayoutRTL )
294 0 : nTotalWidth += 2*rOffset.X();
295 :
296 0 : bool bVScroll = aViewData.IsVScrollMode();
297 0 : bool bHScroll = aViewData.IsHScrollMode();
298 0 : bool bTabControl = aViewData.IsTabMode();
299 0 : bool bHeaders = aViewData.IsHeaderMode();
300 0 : bool bOutlMode = aViewData.IsOutlineMode();
301 0 : bool bHOutline = bOutlMode && lcl_HasColOutline(aViewData);
302 0 : bool bVOutline = bOutlMode && lcl_HasRowOutline(aViewData);
303 :
304 0 : if ( aViewData.GetDocShell()->IsPreview() )
305 0 : bHScroll = bVScroll = bTabControl = bHeaders = bOutlMode = bHOutline = bVOutline = false;
306 :
307 0 : long nBarX = 0;
308 0 : long nBarY = 0;
309 0 : long nOutlineX = 0;
310 0 : long nOutlineY = 0;
311 : long nOutPosX;
312 : long nOutPosY;
313 :
314 0 : long nPosX = rOffset.X();
315 0 : long nPosY = rOffset.Y();
316 0 : long nSizeX = rSize.Width();
317 0 : long nSizeY = rSize.Height();
318 :
319 0 : bMinimized = ( nSizeX<=SC_ICONSIZE || nSizeY<=SC_ICONSIZE );
320 0 : if ( bMinimized )
321 0 : return;
322 :
323 0 : long nSplitSizeX = SPLIT_HANDLE_SIZE;
324 0 : if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
325 0 : nSplitSizeX = 1;
326 0 : long nSplitSizeY = SPLIT_HANDLE_SIZE;
327 0 : if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX )
328 0 : nSplitSizeY = 1;
329 :
330 0 : const long nOverlap = 0; // ScrollBar::GetWindowOverlapPixel();
331 :
332 0 : aBorderPos = rOffset;
333 0 : aFrameSize = rSize;
334 :
335 0 : if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE )
336 0 : if ( aViewData.GetHSplitPos() > nSizeX - SPLIT_MARGIN )
337 : {
338 0 : aViewData.SetHSplitMode( SC_SPLIT_NONE );
339 0 : if ( WhichH( aViewData.GetActivePart() ) == SC_SPLIT_RIGHT )
340 0 : ActivatePart( SC_SPLIT_BOTTOMLEFT );
341 0 : InvalidateSplit();
342 : }
343 0 : if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
344 0 : if ( aViewData.GetVSplitPos() > nSizeY - SPLIT_MARGIN )
345 : {
346 0 : aViewData.SetVSplitMode( SC_SPLIT_NONE );
347 0 : if ( WhichV( aViewData.GetActivePart() ) == SC_SPLIT_TOP )
348 0 : ActivatePart( SC_SPLIT_BOTTOMLEFT );
349 0 : InvalidateSplit();
350 : }
351 :
352 0 : UpdateShow();
353 :
354 0 : if (bHScroll || bVScroll) // Scrollbars horizontal oder vertikal
355 : {
356 0 : long nScrollBarSize = pFrameWin->GetSettings().GetStyleSettings().GetScrollBarSize();
357 0 : if (bVScroll)
358 : {
359 0 : nBarX = nScrollBarSize;
360 0 : nSizeX -= nBarX - nOverlap;
361 : }
362 0 : if (bHScroll)
363 : {
364 0 : nBarY = nScrollBarSize;
365 0 : nSizeY -= nBarY - nOverlap;
366 : }
367 :
368 : // window at the bottom right
369 : lcl_SetPosSize( aScrollBarBox, Point( nPosX+nSizeX, nPosY+nSizeY ), Size( nBarX, nBarY ),
370 0 : nTotalWidth, bLayoutRTL );
371 :
372 0 : if (bHScroll) // Scrollbars horizontal
373 : {
374 0 : long nSizeLt = 0; // left scroll bar
375 0 : long nSizeRt = 0; // right scroll bar
376 0 : long nSizeSp = 0; // splitter
377 :
378 0 : switch (aViewData.GetHSplitMode())
379 : {
380 : case SC_SPLIT_NONE:
381 0 : nSizeSp = nSplitSizeX;
382 0 : nSizeLt = nSizeX - nSizeSp + nOverlap; // Ecke ueberdecken
383 0 : break;
384 : case SC_SPLIT_NORMAL:
385 0 : nSizeSp = nSplitSizeX;
386 0 : nSizeLt = aViewData.GetHSplitPos();
387 0 : break;
388 : case SC_SPLIT_FIX:
389 0 : nSizeSp = 0;
390 0 : nSizeLt = 0;
391 0 : break;
392 : }
393 0 : nSizeRt = nSizeX - nSizeLt - nSizeSp;
394 :
395 0 : long nTabSize = 0;
396 0 : if (bTabControl)
397 : {
398 : // pending relative tab bar width from extended document options
399 0 : if( mfPendingTabBarWidth >= 0.0 )
400 : {
401 0 : SetRelTabBarWidth( mfPendingTabBarWidth );
402 0 : mfPendingTabBarWidth = -1.0;
403 : }
404 :
405 0 : nTabSize = pTabControl->GetSizePixel().Width()-nOverlap;
406 :
407 0 : if ( aViewData.GetHSplitMode() != SC_SPLIT_FIX ) // bei linkem Scrollbar
408 : {
409 0 : if (nTabSize > nSizeLt-SC_SCROLLBAR_MIN) nTabSize = nSizeLt-SC_SCROLLBAR_MIN;
410 0 : if (nTabSize < SC_TABBAR_MIN) nTabSize = SC_TABBAR_MIN;
411 0 : nSizeLt -= nTabSize;
412 : }
413 : else // bei rechtem Scrollbar
414 : {
415 0 : if (nTabSize > nSizeRt-SC_SCROLLBAR_MIN) nTabSize = nSizeRt-SC_SCROLLBAR_MIN;
416 0 : if (nTabSize < SC_TABBAR_MIN) nTabSize = SC_TABBAR_MIN;
417 0 : nSizeRt -= nTabSize;
418 : }
419 : }
420 :
421 : lcl_SetPosSize( *pTabControl, Point(nPosX-nOverlap, nPosY+nSizeY),
422 0 : Size(nTabSize+nOverlap, nBarY), nTotalWidth, bLayoutRTL );
423 0 : pTabControl->SetSheetLayoutRTL( bLayoutRTL );
424 :
425 : lcl_SetPosSize( aHScrollLeft, Point(nPosX+nTabSize-nOverlap, nPosY+nSizeY),
426 0 : Size(nSizeLt+2*nOverlap, nBarY), nTotalWidth, bLayoutRTL );
427 0 : lcl_SetPosSize( *pHSplitter, Point( nPosX+nTabSize+nSizeLt, nPosY+nSizeY ),
428 0 : Size( nSizeSp, nBarY ), nTotalWidth, bLayoutRTL );
429 0 : lcl_SetPosSize( aHScrollRight, Point(nPosX+nTabSize+nSizeLt+nSizeSp-nOverlap,
430 : nPosY+nSizeY),
431 0 : Size(nSizeRt+2*nOverlap, nBarY), nTotalWidth, bLayoutRTL );
432 :
433 : // SetDragRectPixel is done below
434 : }
435 :
436 0 : if (bVScroll) // Scrollbars vertikal
437 : {
438 0 : long nSizeUp = 0; // upper scroll bar
439 0 : long nSizeSp = 0; // splitter
440 : long nSizeDn; // unterer Scrollbar
441 :
442 0 : switch (aViewData.GetVSplitMode())
443 : {
444 : case SC_SPLIT_NONE:
445 0 : nSizeUp = 0;
446 0 : nSizeSp = nSplitSizeY;
447 0 : break;
448 : case SC_SPLIT_NORMAL:
449 0 : nSizeUp = aViewData.GetVSplitPos();
450 0 : nSizeSp = nSplitSizeY;
451 0 : break;
452 : case SC_SPLIT_FIX:
453 0 : nSizeUp = 0;
454 0 : nSizeSp = 0;
455 0 : break;
456 : }
457 0 : nSizeDn = nSizeY - nSizeUp - nSizeSp;
458 :
459 : lcl_SetPosSize( aVScrollTop, Point(nPosX+nSizeX, nPosY-nOverlap),
460 0 : Size(nBarX,nSizeUp+2*nOverlap), nTotalWidth, bLayoutRTL );
461 : lcl_SetPosSize( *pVSplitter, Point( nPosX+nSizeX, nPosY+nSizeUp ),
462 0 : Size( nBarX, nSizeSp ), nTotalWidth, bLayoutRTL );
463 : lcl_SetPosSize( aVScrollBottom, Point(nPosX+nSizeX,
464 0 : nPosY+nSizeUp+nSizeSp-nOverlap),
465 0 : Size(nBarX, nSizeDn+2*nOverlap), nTotalWidth, bLayoutRTL );
466 :
467 : // SetDragRectPixel is done below
468 : }
469 : }
470 :
471 : // SetDragRectPixel auch ohne Scrollbars etc., wenn schon gesplittet ist
472 0 : if ( bHScroll || aViewData.GetHSplitMode() != SC_SPLIT_NONE )
473 : pHSplitter->SetDragRectPixel(
474 0 : Rectangle( nPosX, nPosY, nPosX+nSizeX, nPosY+nSizeY ), pFrameWin );
475 0 : if ( bVScroll || aViewData.GetVSplitMode() != SC_SPLIT_NONE )
476 : pVSplitter->SetDragRectPixel(
477 0 : Rectangle( nPosX, nPosY, nPosX+nSizeX, nPosY+nSizeY ), pFrameWin );
478 :
479 0 : if (bTabControl && ! bHScroll )
480 : {
481 0 : nBarY = aHScrollLeft.GetSizePixel().Height();
482 0 : nBarX = aVScrollBottom.GetSizePixel().Width();
483 :
484 0 : long nSize1 = nSizeX + nOverlap;
485 :
486 0 : long nTabSize = nSize1;
487 0 : if (nTabSize < 0) nTabSize = 0;
488 :
489 0 : lcl_SetPosSize( *pTabControl, Point(nPosX-nOverlap, nPosY+nSizeY-nBarY),
490 0 : Size(nTabSize+nOverlap, nBarY), nTotalWidth, bLayoutRTL );
491 0 : nSizeY -= nBarY - nOverlap;
492 : lcl_SetPosSize( aScrollBarBox, Point( nPosX+nSizeX, nPosY+nSizeY ), Size( nBarX, nBarY ),
493 0 : nTotalWidth, bLayoutRTL );
494 :
495 0 : if( bVScroll )
496 : {
497 0 : Size aVScrSize = aVScrollBottom.GetSizePixel();
498 0 : aVScrSize.Height() -= nBarY;
499 0 : aVScrollBottom.SetSizePixel( aVScrSize );
500 : }
501 : }
502 :
503 0 : nOutPosX = nPosX;
504 0 : nOutPosY = nPosY;
505 :
506 : // Outline-Controls
507 0 : if (bVOutline && pRowOutline[SC_SPLIT_BOTTOM])
508 : {
509 0 : nOutlineX = pRowOutline[SC_SPLIT_BOTTOM]->GetDepthSize();
510 0 : nSizeX -= nOutlineX;
511 0 : nPosX += nOutlineX;
512 : }
513 0 : if (bHOutline && pColOutline[SC_SPLIT_LEFT])
514 : {
515 0 : nOutlineY = pColOutline[SC_SPLIT_LEFT]->GetDepthSize();
516 0 : nSizeY -= nOutlineY;
517 0 : nPosY += nOutlineY;
518 : }
519 :
520 0 : if (bHeaders) // Spalten/Zeilen-Header
521 : {
522 0 : nBarX = pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width();
523 0 : nBarY = pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height();
524 0 : nSizeX -= nBarX;
525 0 : nSizeY -= nBarY;
526 0 : nPosX += nBarX;
527 0 : nPosY += nBarY;
528 : }
529 : else
530 0 : nBarX = nBarY = 0;
531 :
532 :
533 : // Splitter auswerten
534 :
535 :
536 0 : long nLeftSize = nSizeX;
537 0 : long nRightSize = 0;
538 0 : long nTopSize = 0;
539 0 : long nBottomSize = nSizeY;
540 0 : long nSplitPosX = nPosX;
541 0 : long nSplitPosY = nPosY;
542 :
543 0 : if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE )
544 : {
545 0 : long nSplitHeight = rSize.Height();
546 0 : if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
547 : {
548 : // Fixier-Splitter nicht mit Scrollbar/TabBar ueberlappen lassen
549 0 : if ( bHScroll )
550 0 : nSplitHeight -= aHScrollLeft.GetSizePixel().Height();
551 0 : else if ( bTabControl && pTabControl )
552 0 : nSplitHeight -= pTabControl->GetSizePixel().Height();
553 : }
554 0 : nSplitPosX = aViewData.GetHSplitPos();
555 : lcl_SetPosSize( *pHSplitter,
556 0 : Point( nSplitPosX, nOutPosY ), Size( nSplitSizeX, nSplitHeight ), nTotalWidth, bLayoutRTL );
557 0 : nLeftSize = nSplitPosX - nPosX;
558 0 : nSplitPosX += nSplitSizeX;
559 0 : nRightSize = nSizeX - nLeftSize - nSplitSizeX;
560 : }
561 0 : if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
562 : {
563 0 : long nSplitWidth = rSize.Width();
564 0 : if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX && bVScroll )
565 0 : nSplitWidth -= aVScrollBottom.GetSizePixel().Width();
566 0 : nSplitPosY = aViewData.GetVSplitPos();
567 : lcl_SetPosSize( *pVSplitter,
568 0 : Point( nOutPosX, nSplitPosY ), Size( nSplitWidth, nSplitSizeY ), nTotalWidth, bLayoutRTL );
569 0 : nTopSize = nSplitPosY - nPosY;
570 0 : nSplitPosY += nSplitSizeY;
571 0 : nBottomSize = nSizeY - nTopSize - nSplitSizeY;
572 : }
573 :
574 : // ShowHide fuer pColOutline / pRowOutline passiert in UpdateShow
575 :
576 0 : if (bHOutline) // Outline-Controls
577 : {
578 0 : if (pColOutline[SC_SPLIT_LEFT])
579 : {
580 0 : pColOutline[SC_SPLIT_LEFT]->SetHeaderSize( nBarX );
581 0 : lcl_SetPosSize( *pColOutline[SC_SPLIT_LEFT],
582 0 : Point(nPosX-nBarX,nOutPosY), Size(nLeftSize+nBarX,nOutlineY), nTotalWidth, bLayoutRTL );
583 : }
584 0 : if (pColOutline[SC_SPLIT_RIGHT])
585 : {
586 0 : pColOutline[SC_SPLIT_RIGHT]->SetHeaderSize( 0 ); // always call to update RTL flag
587 0 : lcl_SetPosSize( *pColOutline[SC_SPLIT_RIGHT],
588 0 : Point(nSplitPosX,nOutPosY), Size(nRightSize,nOutlineY), nTotalWidth, bLayoutRTL );
589 : }
590 : }
591 0 : if (bVOutline)
592 : {
593 0 : if (nTopSize)
594 : {
595 0 : if (pRowOutline[SC_SPLIT_TOP] && pRowOutline[SC_SPLIT_BOTTOM])
596 : {
597 0 : pRowOutline[SC_SPLIT_TOP]->SetHeaderSize( nBarY );
598 0 : lcl_SetPosSize( *pRowOutline[SC_SPLIT_TOP],
599 0 : Point(nOutPosX,nPosY-nBarY), Size(nOutlineX,nTopSize+nBarY), nTotalWidth, bLayoutRTL );
600 0 : pRowOutline[SC_SPLIT_BOTTOM]->SetHeaderSize( 0 );
601 0 : lcl_SetPosSize( *pRowOutline[SC_SPLIT_BOTTOM],
602 0 : Point(nOutPosX,nSplitPosY), Size(nOutlineX,nBottomSize), nTotalWidth, bLayoutRTL );
603 : }
604 : }
605 0 : else if (pRowOutline[SC_SPLIT_BOTTOM])
606 : {
607 0 : pRowOutline[SC_SPLIT_BOTTOM]->SetHeaderSize( nBarY );
608 0 : lcl_SetPosSize( *pRowOutline[SC_SPLIT_BOTTOM],
609 0 : Point(nOutPosX,nSplitPosY-nBarY), Size(nOutlineX,nBottomSize+nBarY), nTotalWidth, bLayoutRTL );
610 : }
611 : }
612 0 : if (bHOutline && bVOutline)
613 : {
614 0 : lcl_SetPosSize( aTopButton, Point(nOutPosX,nOutPosY), Size(nOutlineX,nOutlineY), nTotalWidth, bLayoutRTL );
615 0 : aTopButton.Show();
616 : }
617 : else
618 0 : aTopButton.Hide();
619 :
620 0 : if (bHeaders) // Spalten/Zeilen-Header
621 : {
622 0 : lcl_SetPosSize( *pColBar[SC_SPLIT_LEFT],
623 0 : Point(nPosX,nPosY-nBarY), Size(nLeftSize,nBarY), nTotalWidth, bLayoutRTL );
624 0 : if (pColBar[SC_SPLIT_RIGHT])
625 0 : lcl_SetPosSize( *pColBar[SC_SPLIT_RIGHT],
626 0 : Point(nSplitPosX,nPosY-nBarY), Size(nRightSize,nBarY), nTotalWidth, bLayoutRTL );
627 :
628 0 : if (pRowBar[SC_SPLIT_TOP])
629 0 : lcl_SetPosSize( *pRowBar[SC_SPLIT_TOP],
630 0 : Point(nPosX-nBarX,nPosY), Size(nBarX,nTopSize), nTotalWidth, bLayoutRTL );
631 0 : lcl_SetPosSize( *pRowBar[SC_SPLIT_BOTTOM],
632 0 : Point(nPosX-nBarX,nSplitPosY), Size(nBarX,nBottomSize), nTotalWidth, bLayoutRTL );
633 :
634 0 : lcl_SetPosSize( aCornerButton, Point(nPosX-nBarX,nPosY-nBarY), Size(nBarX,nBarY), nTotalWidth, bLayoutRTL );
635 0 : aCornerButton.Show();
636 0 : pColBar[SC_SPLIT_LEFT]->Show();
637 0 : pRowBar[SC_SPLIT_BOTTOM]->Show();
638 : }
639 : else
640 : {
641 0 : aCornerButton.Hide();
642 0 : pColBar[SC_SPLIT_LEFT]->Hide(); // immer da
643 0 : pRowBar[SC_SPLIT_BOTTOM]->Hide();
644 : }
645 :
646 :
647 : // Grid-Windows
648 :
649 0 : if (bInner)
650 : {
651 0 : long nInnerPosX = bLayoutRTL ? ( nTotalWidth - nPosX - nLeftSize ) : nPosX;
652 0 : pGridWin[SC_SPLIT_BOTTOMLEFT]->SetPosPixel( Point(nInnerPosX,nSplitPosY) );
653 : }
654 : else
655 : {
656 0 : lcl_SetPosSize( *pGridWin[SC_SPLIT_BOTTOMLEFT],
657 0 : Point(nPosX,nSplitPosY), Size(nLeftSize,nBottomSize), nTotalWidth, bLayoutRTL );
658 0 : if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE )
659 0 : lcl_SetPosSize( *pGridWin[SC_SPLIT_BOTTOMRIGHT],
660 0 : Point(nSplitPosX,nSplitPosY), Size(nRightSize,nBottomSize), nTotalWidth, bLayoutRTL );
661 0 : if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
662 0 : lcl_SetPosSize( *pGridWin[SC_SPLIT_TOPLEFT],
663 0 : Point(nPosX,nPosY), Size(nLeftSize,nTopSize), nTotalWidth, bLayoutRTL );
664 0 : if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE && aViewData.GetVSplitMode() != SC_SPLIT_NONE )
665 0 : lcl_SetPosSize( *pGridWin[SC_SPLIT_TOPRIGHT],
666 0 : Point(nSplitPosX,nPosY), Size(nRightSize,nTopSize), nTotalWidth, bLayoutRTL );
667 : }
668 :
669 :
670 : // Scrollbars updaten
671 :
672 :
673 0 : if (!bInUpdateHeader)
674 : {
675 0 : UpdateScrollBars(); // Scrollbars nicht beim Scrollen neu setzen
676 0 : UpdateHeaderWidth();
677 :
678 0 : InterpretVisible(); // have everything calculated before painting
679 : }
680 :
681 0 : if (bHasHint)
682 0 : TestHintWindow(); // neu positionieren
683 :
684 0 : UpdateVarZoom(); // update variable zoom types (after resizing GridWindows)
685 :
686 0 : if (aViewData.GetViewShell()->HasAccessibilityObjects())
687 0 : aViewData.GetViewShell()->BroadcastAccessibility(SfxSimpleHint(SC_HINT_ACC_WINDOWRESIZED));
688 : }
689 :
690 0 : void ScTabView::UpdateVarZoom()
691 : {
692 : // update variable zoom types
693 :
694 0 : SvxZoomType eZoomType = GetZoomType();
695 0 : if ( eZoomType != SVX_ZOOM_PERCENT && !bInZoomUpdate )
696 : {
697 0 : bInZoomUpdate = true;
698 0 : const Fraction& rOldX = GetViewData()->GetZoomX();
699 0 : const Fraction& rOldY = GetViewData()->GetZoomY();
700 0 : long nOldPercent = ( rOldY.GetNumerator() * 100 ) / rOldY.GetDenominator();
701 0 : sal_uInt16 nNewZoom = CalcZoom( eZoomType, (sal_uInt16)nOldPercent );
702 0 : Fraction aNew( nNewZoom, 100 );
703 :
704 0 : if ( aNew != rOldX || aNew != rOldY )
705 : {
706 0 : SetZoom( aNew, aNew, false ); // always separately per sheet
707 0 : PaintGrid();
708 0 : PaintTop();
709 0 : PaintLeft();
710 0 : aViewData.GetViewShell()->GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOM );
711 0 : aViewData.GetViewShell()->GetViewFrame()->GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
712 : }
713 0 : bInZoomUpdate = false;
714 : }
715 0 : }
716 :
717 0 : void ScTabView::UpdateFixPos()
718 : {
719 0 : bool bResize = false;
720 0 : if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
721 0 : if (aViewData.UpdateFixX())
722 0 : bResize = true;
723 0 : if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX )
724 0 : if (aViewData.UpdateFixY())
725 0 : bResize = true;
726 0 : if (bResize)
727 0 : RepeatResize(false);
728 0 : }
729 :
730 0 : void ScTabView::RepeatResize( bool bUpdateFix )
731 : {
732 0 : if ( bUpdateFix )
733 : {
734 0 : ScSplitMode eHSplit = aViewData.GetHSplitMode();
735 0 : ScSplitMode eVSplit = aViewData.GetVSplitMode();
736 :
737 : // #i46796# UpdateFixX / UpdateFixY uses GetGridOffset, which requires the
738 : // outline windows to be available. So UpdateShow has to be called before
739 : // (also called from DoResize).
740 0 : if ( eHSplit == SC_SPLIT_FIX || eVSplit == SC_SPLIT_FIX )
741 0 : UpdateShow();
742 :
743 0 : if ( eHSplit == SC_SPLIT_FIX )
744 0 : aViewData.UpdateFixX();
745 0 : if ( eVSplit == SC_SPLIT_FIX )
746 0 : aViewData.UpdateFixY();
747 : }
748 :
749 0 : DoResize( aBorderPos, aFrameSize );
750 :
751 : //! Border muss neu gesetzt werden ???
752 0 : }
753 :
754 0 : void ScTabView::GetBorderSize( SvBorder& rBorder, const Size& /* rSize */ )
755 : {
756 0 : sal_Bool bScrollBars = aViewData.IsVScrollMode();
757 0 : sal_Bool bHeaders = aViewData.IsHeaderMode();
758 0 : sal_Bool bOutlMode = aViewData.IsOutlineMode();
759 0 : sal_Bool bHOutline = bOutlMode && lcl_HasColOutline(aViewData);
760 0 : sal_Bool bVOutline = bOutlMode && lcl_HasRowOutline(aViewData);
761 0 : sal_Bool bLayoutRTL = aViewData.GetDocument()->IsLayoutRTL( aViewData.GetTabNo() );
762 :
763 0 : rBorder = SvBorder();
764 :
765 0 : if (bScrollBars) // Scrollbars horizontal oder vertikal
766 : {
767 0 : rBorder.Right() += aVScrollBottom.GetSizePixel().Width();
768 0 : rBorder.Bottom() += aHScrollLeft.GetSizePixel().Height();
769 : }
770 :
771 : // Outline-Controls
772 0 : if (bVOutline && pRowOutline[SC_SPLIT_BOTTOM])
773 0 : rBorder.Left() += pRowOutline[SC_SPLIT_BOTTOM]->GetDepthSize();
774 0 : if (bHOutline && pColOutline[SC_SPLIT_LEFT])
775 0 : rBorder.Top() += pColOutline[SC_SPLIT_LEFT]->GetDepthSize();
776 :
777 0 : if (bHeaders) // Spalten/Zeilen-Header
778 : {
779 0 : rBorder.Left() += pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width();
780 0 : rBorder.Top() += pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height();
781 : }
782 :
783 0 : if ( bLayoutRTL )
784 0 : ::std::swap( rBorder.Left(), rBorder.Right() );
785 0 : }
786 :
787 0 : IMPL_LINK_NOARG(ScTabView, TabBarResize)
788 : {
789 0 : if (aViewData.IsHScrollMode())
790 : {
791 0 : const long nOverlap = 0; // ScrollBar::GetWindowOverlapPixel();
792 0 : long nSize = pTabControl->GetSplitSize();
793 :
794 0 : if (aViewData.GetHSplitMode() != SC_SPLIT_FIX)
795 : {
796 0 : long nMax = pHSplitter->GetPosPixel().X();
797 0 : if( pTabControl->IsEffectiveRTL() )
798 0 : nMax = pFrameWin->GetSizePixel().Width() - nMax;
799 0 : --nMax;
800 0 : if (nSize>nMax) nSize = nMax;
801 : }
802 :
803 0 : if ( nSize != pTabControl->GetSizePixel().Width() )
804 : {
805 : pTabControl->SetSizePixel( Size( nSize+nOverlap,
806 0 : pTabControl->GetSizePixel().Height() ) );
807 0 : RepeatResize();
808 : }
809 : }
810 :
811 0 : return 0;
812 : }
813 :
814 0 : void ScTabView::SetTabBarWidth( long nNewWidth )
815 : {
816 0 : Size aSize = pTabControl->GetSizePixel();
817 :
818 0 : if ( aSize.Width() != nNewWidth )
819 : {
820 0 : aSize.Width() = nNewWidth;
821 0 : pTabControl->SetSizePixel( aSize );
822 : }
823 0 : }
824 :
825 0 : void ScTabView::SetRelTabBarWidth( double fRelTabBarWidth )
826 : {
827 0 : if( (0.0 <= fRelTabBarWidth) && (fRelTabBarWidth <= 1.0) )
828 0 : if( long nFrameWidth = pFrameWin->GetSizePixel().Width() )
829 0 : SetTabBarWidth( static_cast< long >( fRelTabBarWidth * nFrameWidth + 0.5 ) );
830 0 : }
831 :
832 0 : void ScTabView::SetPendingRelTabBarWidth( double fRelTabBarWidth )
833 : {
834 0 : mfPendingTabBarWidth = fRelTabBarWidth;
835 0 : SetRelTabBarWidth( fRelTabBarWidth );
836 0 : }
837 :
838 0 : long ScTabView::GetTabBarWidth() const
839 : {
840 0 : return pTabControl->GetSizePixel().Width();
841 : }
842 :
843 0 : double ScTabView::GetRelTabBarWidth() const
844 : {
845 0 : if( long nFrameWidth = pFrameWin->GetSizePixel().Width() )
846 0 : return static_cast< double >( GetTabBarWidth() ) / nFrameWidth;
847 0 : return 0.0;
848 : }
849 :
850 0 : double ScTabView::GetPendingRelTabBarWidth() const
851 : {
852 0 : return mfPendingTabBarWidth;
853 : }
854 :
855 0 : Window* ScTabView::GetActiveWin()
856 : {
857 0 : ScSplitPos ePos = aViewData.GetActivePart();
858 : OSL_ENSURE(pGridWin[ePos],"kein aktives Fenster");
859 0 : return pGridWin[ePos];
860 : }
861 :
862 0 : Window* ScTabView::GetWindowByPos( ScSplitPos ePos )
863 : {
864 0 : return pGridWin[ePos];
865 : }
866 :
867 0 : void ScTabView::SetActivePointer( const Pointer& rPointer )
868 : {
869 0 : for (sal_uInt16 i=0; i<4; i++)
870 0 : if (pGridWin[i])
871 0 : pGridWin[i]->SetPointer( rPointer );
872 0 : }
873 :
874 :
875 0 : void ScTabView::ActiveGrabFocus()
876 : {
877 0 : ScSplitPos ePos = aViewData.GetActivePart();
878 0 : if (pGridWin[ePos])
879 0 : pGridWin[ePos]->GrabFocus();
880 0 : }
881 :
882 :
883 0 : ScSplitPos ScTabView::FindWindow( Window* pWindow ) const
884 : {
885 0 : ScSplitPos eVal = SC_SPLIT_BOTTOMLEFT; // Default
886 0 : for (sal_uInt16 i=0; i<4; i++)
887 0 : if ( pGridWin[i] == pWindow )
888 0 : eVal = (ScSplitPos) i;
889 :
890 0 : return eVal;
891 : }
892 :
893 0 : Point ScTabView::GetGridOffset() const
894 : {
895 0 : Point aPos;
896 :
897 : // Groessen hier wie in DoResize
898 :
899 0 : sal_Bool bHeaders = aViewData.IsHeaderMode();
900 0 : sal_Bool bOutlMode = aViewData.IsOutlineMode();
901 0 : sal_Bool bHOutline = bOutlMode && lcl_HasColOutline(aViewData);
902 0 : sal_Bool bVOutline = bOutlMode && lcl_HasRowOutline(aViewData);
903 :
904 : // Outline-Controls
905 0 : if (bVOutline && pRowOutline[SC_SPLIT_BOTTOM])
906 0 : aPos.X() += pRowOutline[SC_SPLIT_BOTTOM]->GetDepthSize();
907 0 : if (bHOutline && pColOutline[SC_SPLIT_LEFT])
908 0 : aPos.Y() += pColOutline[SC_SPLIT_LEFT]->GetDepthSize();
909 :
910 0 : if (bHeaders) // Spalten/Zeilen-Header
911 : {
912 0 : if (pRowBar[SC_SPLIT_BOTTOM])
913 0 : aPos.X() += pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width();
914 0 : if (pColBar[SC_SPLIT_LEFT])
915 0 : aPos.Y() += pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height();
916 : }
917 :
918 0 : return aPos;
919 : }
920 :
921 : // --- Scroll-Bars --------------------------------------------------------
922 :
923 0 : bool ScTabView::ScrollCommand( const CommandEvent& rCEvt, ScSplitPos ePos )
924 : {
925 0 : HideNoteMarker();
926 :
927 0 : bool bDone = false;
928 0 : const CommandWheelData* pData = rCEvt.GetWheelData();
929 0 : if ( pData && (pData->GetMode() == COMMAND_WHEEL_ZOOM ||
930 0 : pData->GetMode() == COMMAND_WHEEL_ZOOM_SCALE ) )
931 : {
932 0 : if ( !aViewData.GetViewShell()->GetViewFrame()->GetFrame().IsInPlace() )
933 : {
934 : // for ole inplace editing, the scale is defined by the visarea and client size
935 : // and can't be changed directly
936 :
937 0 : const Fraction& rOldY = aViewData.GetZoomY();
938 0 : long nOld = (long)(( rOldY.GetNumerator() * 100 ) / rOldY.GetDenominator());
939 0 : long nNew = nOld;
940 0 : if ( pData->GetMode() == COMMAND_WHEEL_ZOOM_SCALE )
941 : {
942 0 : nNew = 100 * (long) ((nOld / 100.0) * (pData->GetDelta() / 100.0));
943 : } else
944 : {
945 0 : if ( pData->GetDelta() < 0 )
946 0 : nNew = std::max( (long) MINZOOM, basegfx::zoomtools::zoomOut( nOld ));
947 : else
948 0 : nNew = std::min( (long) MAXZOOM, basegfx::zoomtools::zoomIn( nOld ));
949 : }
950 0 : if ( nNew != nOld )
951 : {
952 : // scroll wheel doesn't set the AppOptions default
953 :
954 0 : bool bSyncZoom = SC_MOD()->GetAppOptions().GetSynchronizeZoom();
955 0 : SetZoomType( SVX_ZOOM_PERCENT, bSyncZoom );
956 0 : Fraction aFract( nNew, 100 );
957 0 : SetZoom( aFract, aFract, bSyncZoom );
958 0 : PaintGrid();
959 0 : PaintTop();
960 0 : PaintLeft();
961 0 : aViewData.GetBindings().Invalidate( SID_ATTR_ZOOM );
962 0 : aViewData.GetBindings().Invalidate( SID_ATTR_ZOOMSLIDER );
963 : }
964 :
965 0 : bDone = true;
966 : }
967 : }
968 : else
969 : {
970 0 : ScHSplitPos eHPos = WhichH(ePos);
971 0 : ScVSplitPos eVPos = WhichV(ePos);
972 0 : ScrollBar* pHScroll = ( eHPos == SC_SPLIT_LEFT ) ? &aHScrollLeft : &aHScrollRight;
973 0 : ScrollBar* pVScroll = ( eVPos == SC_SPLIT_TOP ) ? &aVScrollTop : &aVScrollBottom;
974 0 : if ( pGridWin[ePos] )
975 0 : bDone = pGridWin[ePos]->HandleScrollCommand( rCEvt, pHScroll, pVScroll );
976 : }
977 0 : return bDone;
978 : }
979 :
980 0 : IMPL_LINK_NOARG(ScTabView, EndScrollHdl)
981 : {
982 0 : if ( bDragging )
983 : {
984 0 : UpdateScrollBars();
985 0 : bDragging = false;
986 : }
987 0 : return 0;
988 : }
989 :
990 0 : IMPL_LINK( ScTabView, ScrollHdl, ScrollBar*, pScroll )
991 : {
992 0 : bool bHoriz = ( pScroll == &aHScrollLeft || pScroll == &aHScrollRight );
993 : long nViewPos;
994 0 : if ( bHoriz )
995 : nViewPos = aViewData.GetPosX( (pScroll == &aHScrollLeft) ?
996 0 : SC_SPLIT_LEFT : SC_SPLIT_RIGHT );
997 : else
998 : nViewPos = aViewData.GetPosY( (pScroll == &aVScrollTop) ?
999 0 : SC_SPLIT_TOP : SC_SPLIT_BOTTOM );
1000 :
1001 0 : bool bLayoutRTL = aViewData.GetDocument()->IsLayoutRTL( aViewData.GetTabNo() );
1002 :
1003 0 : ScrollType eType = pScroll->GetType();
1004 0 : if ( eType == SCROLL_DRAG )
1005 : {
1006 0 : if (!bDragging)
1007 : {
1008 0 : bDragging = true;
1009 0 : nPrevDragPos = nViewPos;
1010 : }
1011 :
1012 : // Scroll-Position anzeigen
1013 : // (nur QuickHelp, in der Statuszeile gibt es keinen Eintrag dafuer)
1014 :
1015 0 : if (Help::IsQuickHelpEnabled())
1016 : {
1017 0 : Size aSize = pScroll->GetSizePixel();
1018 :
1019 : /* Convert scrollbar mouse position to screen position. If RTL
1020 : mode of scrollbar differs from RTL mode of its parent, then the
1021 : direct call to Window::OutputToNormalizedScreenPixel() will
1022 : give unusable results, because calcualtion of screen position
1023 : is based on parent orientation and expects equal orientation of
1024 : the child position. Need to mirror mouse position before. */
1025 0 : Point aMousePos = pScroll->GetPointerPosPixel();
1026 0 : if( pScroll->IsRTLEnabled() != pScroll->GetParent()->IsRTLEnabled() )
1027 0 : aMousePos.X() = aSize.Width() - aMousePos.X() - 1;
1028 0 : aMousePos = pScroll->OutputToNormalizedScreenPixel( aMousePos );
1029 :
1030 : // convert top-left position of scrollbar to screen position
1031 0 : Point aPos = pScroll->OutputToNormalizedScreenPixel( Point() );
1032 :
1033 : // get scrollbar scroll position for help text (row number/column name)
1034 0 : long nScrollMin = 0; // RangeMin simulieren
1035 0 : if ( aViewData.GetHSplitMode()==SC_SPLIT_FIX && pScroll == &aHScrollRight )
1036 0 : nScrollMin = aViewData.GetFixPosX();
1037 0 : if ( aViewData.GetVSplitMode()==SC_SPLIT_FIX && pScroll == &aVScrollBottom )
1038 0 : nScrollMin = aViewData.GetFixPosY();
1039 0 : long nScrollPos = GetScrollBarPos( *pScroll ) + nScrollMin;
1040 :
1041 0 : OUString aHelpStr;
1042 0 : Rectangle aRect;
1043 : sal_uInt16 nAlign;
1044 0 : if (bHoriz)
1045 : {
1046 0 : aHelpStr = ScGlobal::GetRscString(STR_COLUMN) +
1047 0 : " " + ScColToAlpha((SCCOL) nScrollPos);
1048 :
1049 0 : aRect.Left() = aMousePos.X();
1050 0 : aRect.Top() = aPos.Y() - 4;
1051 0 : nAlign = QUICKHELP_BOTTOM|QUICKHELP_CENTER;
1052 : }
1053 : else
1054 : {
1055 0 : aHelpStr = ScGlobal::GetRscString(STR_ROW) +
1056 0 : " " + OUString::number(nScrollPos + 1);
1057 :
1058 : // show quicktext always inside sheet area
1059 0 : aRect.Left() = bLayoutRTL ? (aPos.X() + aSize.Width() + 8) : (aPos.X() - 8);
1060 0 : aRect.Top() = aMousePos.Y();
1061 0 : nAlign = (bLayoutRTL ? QUICKHELP_LEFT : QUICKHELP_RIGHT) | QUICKHELP_VCENTER;
1062 : }
1063 0 : aRect.Right() = aRect.Left();
1064 0 : aRect.Bottom() = aRect.Top();
1065 :
1066 0 : Help::ShowQuickHelp(pScroll->GetParent(), aRect, aHelpStr, nAlign);
1067 : }
1068 : }
1069 :
1070 0 : long nDelta = pScroll->GetDelta();
1071 0 : switch ( eType )
1072 : {
1073 : case SCROLL_LINEUP:
1074 0 : nDelta = -1;
1075 0 : break;
1076 : case SCROLL_LINEDOWN:
1077 0 : nDelta = 1;
1078 0 : break;
1079 : case SCROLL_PAGEUP:
1080 0 : if ( pScroll == &aHScrollLeft ) nDelta = -(long) aViewData.PrevCellsX( SC_SPLIT_LEFT );
1081 0 : if ( pScroll == &aHScrollRight ) nDelta = -(long) aViewData.PrevCellsX( SC_SPLIT_RIGHT );
1082 0 : if ( pScroll == &aVScrollTop ) nDelta = -(long) aViewData.PrevCellsY( SC_SPLIT_TOP );
1083 0 : if ( pScroll == &aVScrollBottom ) nDelta = -(long) aViewData.PrevCellsY( SC_SPLIT_BOTTOM );
1084 0 : if (nDelta==0) nDelta=-1;
1085 0 : break;
1086 : case SCROLL_PAGEDOWN:
1087 0 : if ( pScroll == &aHScrollLeft ) nDelta = aViewData.VisibleCellsX( SC_SPLIT_LEFT );
1088 0 : if ( pScroll == &aHScrollRight ) nDelta = aViewData.VisibleCellsX( SC_SPLIT_RIGHT );
1089 0 : if ( pScroll == &aVScrollTop ) nDelta = aViewData.VisibleCellsY( SC_SPLIT_TOP );
1090 0 : if ( pScroll == &aVScrollBottom ) nDelta = aViewData.VisibleCellsY( SC_SPLIT_BOTTOM );
1091 0 : if (nDelta==0) nDelta=1;
1092 0 : break;
1093 : case SCROLL_DRAG:
1094 : {
1095 : // nur in die richtige Richtung scrollen, nicht um ausgeblendete
1096 : // Bereiche herumzittern
1097 :
1098 0 : long nScrollMin = 0; // RangeMin simulieren
1099 0 : if ( aViewData.GetHSplitMode()==SC_SPLIT_FIX && pScroll == &aHScrollRight )
1100 0 : nScrollMin = aViewData.GetFixPosX();
1101 0 : if ( aViewData.GetVSplitMode()==SC_SPLIT_FIX && pScroll == &aVScrollBottom )
1102 0 : nScrollMin = aViewData.GetFixPosY();
1103 :
1104 0 : long nScrollPos = GetScrollBarPos( *pScroll ) + nScrollMin;
1105 0 : nDelta = nScrollPos - nViewPos;
1106 0 : if ( nScrollPos > nPrevDragPos )
1107 : {
1108 0 : if (nDelta<0) nDelta=0;
1109 : }
1110 0 : else if ( nScrollPos < nPrevDragPos )
1111 : {
1112 0 : if (nDelta>0) nDelta=0;
1113 : }
1114 : else
1115 0 : nDelta = 0;
1116 0 : nPrevDragPos = nScrollPos;
1117 : }
1118 0 : break;
1119 : default:
1120 : {
1121 : // added to avoid warnings
1122 : }
1123 : }
1124 :
1125 0 : if (nDelta)
1126 : {
1127 0 : sal_Bool bUpdate = ( eType != SCROLL_DRAG ); // bei Drag die Ranges nicht aendern
1128 0 : if ( bHoriz )
1129 0 : ScrollX( nDelta, (pScroll == &aHScrollLeft) ? SC_SPLIT_LEFT : SC_SPLIT_RIGHT, bUpdate );
1130 : else
1131 0 : ScrollY( nDelta, (pScroll == &aVScrollTop) ? SC_SPLIT_TOP : SC_SPLIT_BOTTOM, bUpdate );
1132 : }
1133 :
1134 0 : return 0;
1135 : }
1136 :
1137 0 : void ScTabView::ScrollX( long nDeltaX, ScHSplitPos eWhich, bool bUpdBars )
1138 : {
1139 0 : SCCOL nOldX = aViewData.GetPosX(eWhich);
1140 0 : SCsCOL nNewX = static_cast<SCsCOL>(nOldX) + static_cast<SCsCOL>(nDeltaX);
1141 0 : if ( nNewX < 0 )
1142 : {
1143 0 : nDeltaX -= nNewX;
1144 0 : nNewX = 0;
1145 : }
1146 0 : if ( nNewX > MAXCOL )
1147 : {
1148 0 : nDeltaX -= nNewX - MAXCOL;
1149 0 : nNewX = MAXCOL;
1150 : }
1151 :
1152 0 : SCsCOL nDir = ( nDeltaX > 0 ) ? 1 : -1;
1153 0 : ScDocument* pDoc = aViewData.GetDocument();
1154 0 : SCTAB nTab = aViewData.GetTabNo();
1155 0 : while ( pDoc->ColHidden(nNewX, nTab) &&
1156 0 : nNewX+nDir >= 0 && nNewX+nDir <= MAXCOL )
1157 0 : nNewX = sal::static_int_cast<SCsCOL>( nNewX + nDir );
1158 :
1159 : // Fixierung
1160 :
1161 0 : if (aViewData.GetHSplitMode() == SC_SPLIT_FIX)
1162 : {
1163 0 : if (eWhich == SC_SPLIT_LEFT)
1164 0 : nNewX = static_cast<SCsCOL>(nOldX); // links immer stehenlassen
1165 : else
1166 : {
1167 0 : SCsCOL nFixX = static_cast<SCsCOL>(aViewData.GetFixPosX());
1168 0 : if (nNewX < nFixX)
1169 0 : nNewX = nFixX;
1170 : }
1171 : }
1172 0 : if (nNewX == static_cast<SCsCOL>(nOldX))
1173 0 : return;
1174 :
1175 0 : HideAllCursors();
1176 :
1177 0 : if ( nNewX >= 0 && nNewX <= MAXCOL && nDeltaX )
1178 : {
1179 0 : SCCOL nTrackX = std::max( nOldX, static_cast<SCCOL>(nNewX) );
1180 :
1181 : // Mit VCL wirkt Update() im Moment immer auf alle Fenster, beim Update
1182 : // nach dem Scrollen des GridWindow's wuerde darum der Col-/RowBar evtl.
1183 : // mit schon geaenderter Pos. gepainted werden -
1184 : // darum vorher einmal Update am Col-/RowBar
1185 :
1186 0 : if (pColBar[eWhich])
1187 0 : pColBar[eWhich]->Update();
1188 :
1189 0 : long nOldPos = aViewData.GetScrPos( nTrackX, 0, eWhich ).X();
1190 0 : aViewData.SetPosX( eWhich, static_cast<SCCOL>(nNewX) );
1191 0 : long nDiff = aViewData.GetScrPos( nTrackX, 0, eWhich ).X() - nOldPos;
1192 :
1193 0 : if ( eWhich==SC_SPLIT_LEFT )
1194 : {
1195 0 : pGridWin[SC_SPLIT_BOTTOMLEFT]->ScrollPixel( nDiff, 0 );
1196 0 : if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
1197 0 : pGridWin[SC_SPLIT_TOPLEFT]->ScrollPixel( nDiff, 0 );
1198 : }
1199 : else
1200 : {
1201 0 : pGridWin[SC_SPLIT_BOTTOMRIGHT]->ScrollPixel( nDiff, 0 );
1202 0 : if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
1203 0 : pGridWin[SC_SPLIT_TOPRIGHT]->ScrollPixel( nDiff, 0 );
1204 : }
1205 0 : if (pColBar[eWhich]) { pColBar[eWhich]->Scroll( nDiff,0 ); pColBar[eWhich]->Update(); }
1206 0 : if (pColOutline[eWhich]) pColOutline[eWhich]->ScrollPixel( nDiff );
1207 0 : if (bUpdBars)
1208 0 : UpdateScrollBars();
1209 : else
1210 0 : UpdateGrid();
1211 : }
1212 :
1213 0 : if (nDeltaX==1 || nDeltaX==-1)
1214 0 : pGridWin[aViewData.GetActivePart()]->Update();
1215 :
1216 0 : ShowAllCursors();
1217 :
1218 0 : SetNewVisArea(); // MapMode muss schon gesetzt sein
1219 :
1220 0 : TestHintWindow();
1221 : }
1222 :
1223 0 : void ScTabView::ScrollY( long nDeltaY, ScVSplitPos eWhich, bool bUpdBars )
1224 : {
1225 0 : SCROW nOldY = aViewData.GetPosY(eWhich);
1226 0 : SCsROW nNewY = static_cast<SCsROW>(nOldY) + static_cast<SCsROW>(nDeltaY);
1227 0 : if ( nNewY < 0 )
1228 : {
1229 0 : nDeltaY -= nNewY;
1230 0 : nNewY = 0;
1231 : }
1232 0 : if ( nNewY > MAXROW )
1233 : {
1234 0 : nDeltaY -= nNewY - MAXROW;
1235 0 : nNewY = MAXROW;
1236 : }
1237 :
1238 0 : SCsROW nDir = ( nDeltaY > 0 ) ? 1 : -1;
1239 0 : ScDocument* pDoc = aViewData.GetDocument();
1240 0 : SCTAB nTab = aViewData.GetTabNo();
1241 0 : while ( pDoc->RowHidden(nNewY, nTab) &&
1242 0 : nNewY+nDir >= 0 && nNewY+nDir <= MAXROW )
1243 0 : nNewY += nDir;
1244 :
1245 : // Fixierung
1246 :
1247 0 : if (aViewData.GetVSplitMode() == SC_SPLIT_FIX)
1248 : {
1249 0 : if (eWhich == SC_SPLIT_TOP)
1250 0 : nNewY = static_cast<SCsROW>(nOldY); // oben immer stehenlassen
1251 : else
1252 : {
1253 0 : SCsROW nFixY = static_cast<SCsROW>(aViewData.GetFixPosY());
1254 0 : if (nNewY < nFixY)
1255 0 : nNewY = nFixY;
1256 : }
1257 : }
1258 0 : if (nNewY == static_cast<SCsROW>(nOldY))
1259 0 : return;
1260 :
1261 0 : HideAllCursors();
1262 :
1263 0 : if ( nNewY >= 0 && nNewY <= MAXROW && nDeltaY )
1264 : {
1265 0 : SCROW nTrackY = std::max( nOldY, static_cast<SCROW>(nNewY) );
1266 :
1267 : // Zeilenkoepfe anpassen vor dem eigentlichen Scrolling, damit nicht
1268 : // doppelt gepainted werden muss
1269 : // PosY darf dann auch noch nicht umgesetzt sein, neuen Wert uebergeben
1270 0 : SCROW nUNew = static_cast<SCROW>(nNewY);
1271 0 : UpdateHeaderWidth( &eWhich, &nUNew ); // Zeilenkoepfe anpassen
1272 :
1273 0 : if (pRowBar[eWhich])
1274 0 : pRowBar[eWhich]->Update();
1275 :
1276 0 : long nOldPos = aViewData.GetScrPos( 0, nTrackY, eWhich ).Y();
1277 0 : aViewData.SetPosY( eWhich, static_cast<SCROW>(nNewY) );
1278 0 : long nDiff = aViewData.GetScrPos( 0, nTrackY, eWhich ).Y() - nOldPos;
1279 :
1280 0 : if ( eWhich==SC_SPLIT_TOP )
1281 : {
1282 0 : pGridWin[SC_SPLIT_TOPLEFT]->ScrollPixel( 0, nDiff );
1283 0 : if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE )
1284 0 : pGridWin[SC_SPLIT_TOPRIGHT]->ScrollPixel( 0, nDiff );
1285 : }
1286 : else
1287 : {
1288 0 : pGridWin[SC_SPLIT_BOTTOMLEFT]->ScrollPixel( 0, nDiff );
1289 0 : if ( aViewData.GetHSplitMode() != SC_SPLIT_NONE )
1290 0 : pGridWin[SC_SPLIT_BOTTOMRIGHT]->ScrollPixel( 0, nDiff );
1291 : }
1292 0 : if (pRowBar[eWhich]) { pRowBar[eWhich]->Scroll( 0,nDiff ); pRowBar[eWhich]->Update(); }
1293 0 : if (pRowOutline[eWhich]) pRowOutline[eWhich]->ScrollPixel( nDiff );
1294 0 : if (bUpdBars)
1295 0 : UpdateScrollBars();
1296 : else
1297 0 : UpdateGrid();
1298 : }
1299 :
1300 0 : if (nDeltaY==1 || nDeltaY==-1)
1301 0 : pGridWin[aViewData.GetActivePart()]->Update();
1302 :
1303 0 : ShowAllCursors();
1304 :
1305 0 : SetNewVisArea(); // MapMode muss schon gesetzt sein
1306 :
1307 0 : TestHintWindow();
1308 : }
1309 :
1310 0 : void ScTabView::ScrollLines( long nDeltaX, long nDeltaY )
1311 : {
1312 0 : ScSplitPos eWhich = aViewData.GetActivePart();
1313 0 : if (nDeltaX)
1314 0 : ScrollX(nDeltaX,WhichH(eWhich));
1315 0 : if (nDeltaY)
1316 0 : ScrollY(nDeltaY,WhichV(eWhich));
1317 0 : }
1318 :
1319 0 : static SCROW lcl_LastVisible( ScViewData& rViewData )
1320 : {
1321 : // wenn am Dokumentende viele Zeilen ausgeblendet sind (welcher Trottel macht sowas?),
1322 : // soll dadurch nicht auf breite Zeilenkoepfe geschaltet werden
1323 : //! als Member ans Dokument ???
1324 :
1325 0 : ScDocument* pDoc = rViewData.GetDocument();
1326 0 : SCTAB nTab = rViewData.GetTabNo();
1327 :
1328 0 : SCROW nVis = MAXROW;
1329 0 : while ( nVis > 0 && pDoc->GetRowHeight( nVis, nTab ) == 0 )
1330 0 : --nVis;
1331 0 : return nVis;
1332 : }
1333 :
1334 0 : void ScTabView::UpdateHeaderWidth( const ScVSplitPos* pWhich, const SCROW* pPosY )
1335 : {
1336 0 : if ( !pRowBar[SC_SPLIT_BOTTOM] || MAXROW < 10000 )
1337 0 : return;
1338 :
1339 0 : SCROW nEndPos = MAXROW;
1340 0 : if ( !aViewData.GetViewShell()->GetViewFrame()->GetFrame().IsInPlace() )
1341 : {
1342 : // fuer OLE Inplace immer MAXROW
1343 :
1344 0 : if ( pWhich && *pWhich == SC_SPLIT_BOTTOM && pPosY )
1345 0 : nEndPos = *pPosY;
1346 : else
1347 0 : nEndPos = aViewData.GetPosY( SC_SPLIT_BOTTOM );
1348 0 : nEndPos += aViewData.CellsAtY( nEndPos, 1, SC_SPLIT_BOTTOM, SC_SIZE_NONE ); // VisibleCellsY
1349 0 : if (nEndPos > MAXROW)
1350 0 : nEndPos = lcl_LastVisible( aViewData );
1351 :
1352 0 : if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
1353 : {
1354 : SCROW nTopEnd;
1355 0 : if ( pWhich && *pWhich == SC_SPLIT_TOP && pPosY )
1356 0 : nTopEnd = *pPosY;
1357 : else
1358 0 : nTopEnd = aViewData.GetPosY( SC_SPLIT_TOP );
1359 0 : nTopEnd += aViewData.CellsAtY( nTopEnd, 1, SC_SPLIT_TOP, SC_SIZE_NONE );// VisibleCellsY
1360 0 : if (nTopEnd > MAXROW)
1361 0 : nTopEnd = lcl_LastVisible( aViewData );
1362 :
1363 0 : if ( nTopEnd > nEndPos )
1364 0 : nEndPos = nTopEnd;
1365 : }
1366 : }
1367 :
1368 0 : long nSmall = pRowBar[SC_SPLIT_BOTTOM]->GetSmallWidth();
1369 0 : long nBig = pRowBar[SC_SPLIT_BOTTOM]->GetBigWidth();
1370 0 : long nDiff = nBig - nSmall;
1371 :
1372 0 : if (nEndPos>10000)
1373 0 : nEndPos = 10000;
1374 0 : else if (nEndPos<1) // avoid extra step at 0 (when only one row is visible)
1375 0 : nEndPos = 1;
1376 0 : long nWidth = nBig - ( 10000 - nEndPos ) * nDiff / 10000;
1377 :
1378 0 : if ( nWidth != pRowBar[SC_SPLIT_BOTTOM]->GetWidth() && !bInUpdateHeader )
1379 : {
1380 0 : bInUpdateHeader = true;
1381 :
1382 0 : pRowBar[SC_SPLIT_BOTTOM]->SetWidth( nWidth );
1383 0 : if (pRowBar[SC_SPLIT_TOP])
1384 0 : pRowBar[SC_SPLIT_TOP]->SetWidth( nWidth );
1385 :
1386 0 : RepeatResize();
1387 :
1388 : // auf VCL gibt's Update ohne Ende (jedes Update gilt fuer alle Fenster)
1389 : //aCornerButton.Update(); // der bekommt sonst nie ein Update
1390 :
1391 0 : bInUpdateHeader = false;
1392 : }
1393 : }
1394 :
1395 0 : inline void ShowHide( Window* pWin, sal_Bool bShow )
1396 : {
1397 : OSL_ENSURE(pWin || !bShow, "Fenster ist nicht da");
1398 0 : if (pWin)
1399 0 : pWin->Show(bShow);
1400 0 : }
1401 :
1402 0 : void ScTabView::UpdateShow()
1403 : {
1404 0 : sal_Bool bHScrollMode = aViewData.IsHScrollMode();
1405 0 : sal_Bool bVScrollMode = aViewData.IsVScrollMode();
1406 0 : sal_Bool bTabMode = aViewData.IsTabMode();
1407 0 : sal_Bool bOutlMode = aViewData.IsOutlineMode();
1408 0 : sal_Bool bHOutline = bOutlMode && lcl_HasColOutline(aViewData);
1409 0 : sal_Bool bVOutline = bOutlMode && lcl_HasRowOutline(aViewData);
1410 0 : sal_Bool bHeader = aViewData.IsHeaderMode();
1411 :
1412 0 : sal_Bool bShowH = ( aViewData.GetHSplitMode() != SC_SPLIT_NONE );
1413 0 : sal_Bool bShowV = ( aViewData.GetVSplitMode() != SC_SPLIT_NONE );
1414 :
1415 0 : if ( aViewData.GetDocShell()->IsPreview() )
1416 0 : bHScrollMode = bVScrollMode = bTabMode = bHeader = bOutlMode = bHOutline = bVOutline = false;
1417 :
1418 :
1419 : // Windows anlegen
1420 :
1421 :
1422 0 : if (bShowH && !pGridWin[SC_SPLIT_BOTTOMRIGHT])
1423 : {
1424 0 : pGridWin[SC_SPLIT_BOTTOMRIGHT] = new ScGridWindow( pFrameWin, &aViewData, SC_SPLIT_BOTTOMRIGHT );
1425 0 : DoAddWin( pGridWin[SC_SPLIT_BOTTOMRIGHT] );
1426 : }
1427 0 : if (bShowV && !pGridWin[SC_SPLIT_TOPLEFT])
1428 : {
1429 0 : pGridWin[SC_SPLIT_TOPLEFT] = new ScGridWindow( pFrameWin, &aViewData, SC_SPLIT_TOPLEFT );
1430 0 : DoAddWin( pGridWin[SC_SPLIT_TOPLEFT] );
1431 : }
1432 0 : if (bShowH && bShowV && !pGridWin[SC_SPLIT_TOPRIGHT])
1433 : {
1434 0 : pGridWin[SC_SPLIT_TOPRIGHT] = new ScGridWindow( pFrameWin, &aViewData, SC_SPLIT_TOPRIGHT );
1435 0 : DoAddWin( pGridWin[SC_SPLIT_TOPRIGHT] );
1436 : }
1437 :
1438 0 : if (bHOutline && !pColOutline[SC_SPLIT_LEFT])
1439 0 : pColOutline[SC_SPLIT_LEFT] = new ScOutlineWindow( pFrameWin, SC_OUTLINE_HOR, &aViewData, SC_SPLIT_BOTTOMLEFT );
1440 0 : if (bShowH && bHOutline && !pColOutline[SC_SPLIT_RIGHT])
1441 0 : pColOutline[SC_SPLIT_RIGHT] = new ScOutlineWindow( pFrameWin, SC_OUTLINE_HOR, &aViewData, SC_SPLIT_BOTTOMRIGHT );
1442 :
1443 0 : if (bVOutline && !pRowOutline[SC_SPLIT_BOTTOM])
1444 0 : pRowOutline[SC_SPLIT_BOTTOM] = new ScOutlineWindow( pFrameWin, SC_OUTLINE_VER, &aViewData, SC_SPLIT_BOTTOMLEFT );
1445 0 : if (bShowV && bVOutline && !pRowOutline[SC_SPLIT_TOP])
1446 0 : pRowOutline[SC_SPLIT_TOP] = new ScOutlineWindow( pFrameWin, SC_OUTLINE_VER, &aViewData, SC_SPLIT_TOPLEFT );
1447 :
1448 0 : if (bShowH && bHeader && !pColBar[SC_SPLIT_RIGHT])
1449 : pColBar[SC_SPLIT_RIGHT] = new ScColBar( pFrameWin, &aViewData, SC_SPLIT_RIGHT,
1450 0 : &aHdrFunc, pHdrSelEng );
1451 0 : if (bShowV && bHeader && !pRowBar[SC_SPLIT_TOP])
1452 : pRowBar[SC_SPLIT_TOP] = new ScRowBar( pFrameWin, &aViewData, SC_SPLIT_TOP,
1453 0 : &aHdrFunc, pHdrSelEng );
1454 :
1455 :
1456 : // Windows anzeigen
1457 :
1458 :
1459 0 : ShowHide( &aHScrollLeft, bHScrollMode );
1460 0 : ShowHide( &aHScrollRight, bShowH && bHScrollMode );
1461 0 : ShowHide( &aVScrollBottom, bVScrollMode );
1462 0 : ShowHide( &aVScrollTop, bShowV && bVScrollMode );
1463 0 : ShowHide( &aScrollBarBox, bVScrollMode || bHScrollMode );
1464 :
1465 0 : ShowHide( pHSplitter, bHScrollMode || bShowH ); // immer angelegt
1466 0 : ShowHide( pVSplitter, bVScrollMode || bShowV );
1467 0 : ShowHide( pTabControl, bTabMode );
1468 :
1469 : // ab hier dynamisch angelegte
1470 :
1471 0 : ShowHide( pGridWin[SC_SPLIT_BOTTOMRIGHT], bShowH );
1472 0 : ShowHide( pGridWin[SC_SPLIT_TOPLEFT], bShowV );
1473 0 : ShowHide( pGridWin[SC_SPLIT_TOPRIGHT], bShowH && bShowV );
1474 :
1475 0 : ShowHide( pColOutline[SC_SPLIT_LEFT], bHOutline );
1476 0 : ShowHide( pColOutline[SC_SPLIT_RIGHT], bShowH && bHOutline );
1477 :
1478 0 : ShowHide( pRowOutline[SC_SPLIT_BOTTOM], bVOutline );
1479 0 : ShowHide( pRowOutline[SC_SPLIT_TOP], bShowV && bVOutline );
1480 :
1481 0 : ShowHide( pColBar[SC_SPLIT_RIGHT], bShowH && bHeader );
1482 0 : ShowHide( pRowBar[SC_SPLIT_TOP], bShowV && bHeader );
1483 :
1484 :
1485 : //! neue Gridwindows eintragen
1486 0 : }
1487 :
1488 0 : bool ScTabView::UpdateVisibleRange()
1489 : {
1490 0 : bool bChanged = false;
1491 0 : for (int i = 0; i < 4; ++i)
1492 : {
1493 0 : if (!pGridWin[i] || !pGridWin[i]->IsVisible())
1494 0 : continue;
1495 :
1496 0 : if (pGridWin[i]->UpdateVisibleRange())
1497 0 : bChanged = true;
1498 : }
1499 :
1500 0 : return bChanged;
1501 : }
1502 :
1503 : // --- Splitter --------------------------------------------------------
1504 :
1505 0 : IMPL_LINK( ScTabView, SplitHdl, Splitter*, pSplitter )
1506 : {
1507 0 : if ( pSplitter == pHSplitter )
1508 0 : DoHSplit( pHSplitter->GetSplitPosPixel() );
1509 : else
1510 0 : DoVSplit( pVSplitter->GetSplitPosPixel() );
1511 :
1512 0 : if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX || aViewData.GetVSplitMode() == SC_SPLIT_FIX )
1513 0 : FreezeSplitters( true );
1514 :
1515 0 : DoResize( aBorderPos, aFrameSize );
1516 :
1517 0 : return 0;
1518 : }
1519 :
1520 0 : void ScTabView::DoHSplit(long nSplitPos)
1521 : {
1522 : // nSplitPos is the real pixel position on the frame window,
1523 : // mirroring for RTL has to be done here.
1524 :
1525 0 : sal_Bool bLayoutRTL = aViewData.GetDocument()->IsLayoutRTL( aViewData.GetTabNo() );
1526 0 : if ( bLayoutRTL )
1527 0 : nSplitPos = pFrameWin->GetOutputSizePixel().Width() - nSplitPos - 1;
1528 :
1529 : long nMinPos;
1530 : long nMaxPos;
1531 : SCCOL nOldDelta;
1532 : SCCOL nNewDelta;
1533 :
1534 0 : nMinPos = SPLIT_MARGIN;
1535 0 : if ( pRowBar[SC_SPLIT_BOTTOM] && pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width() >= nMinPos )
1536 0 : nMinPos = pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width() + 1;
1537 0 : nMaxPos = aFrameSize.Width() - SPLIT_MARGIN;
1538 :
1539 0 : ScSplitMode aOldMode = aViewData.GetHSplitMode();
1540 0 : ScSplitMode aNewMode = SC_SPLIT_NORMAL;
1541 :
1542 0 : aViewData.SetHSplitPos( nSplitPos );
1543 0 : if ( nSplitPos < nMinPos || nSplitPos > nMaxPos )
1544 0 : aNewMode = SC_SPLIT_NONE;
1545 :
1546 0 : aViewData.SetHSplitMode( aNewMode );
1547 :
1548 0 : if ( aNewMode != aOldMode )
1549 : {
1550 0 : UpdateShow(); // vor ActivatePart !!
1551 :
1552 0 : if ( aNewMode == SC_SPLIT_NONE )
1553 : {
1554 0 : if (aViewData.GetActivePart() == SC_SPLIT_TOPRIGHT)
1555 0 : ActivatePart( SC_SPLIT_TOPLEFT );
1556 0 : if (aViewData.GetActivePart() == SC_SPLIT_BOTTOMRIGHT)
1557 0 : ActivatePart( SC_SPLIT_BOTTOMLEFT );
1558 : }
1559 : else
1560 : {
1561 0 : nOldDelta = aViewData.GetPosX( SC_SPLIT_LEFT );
1562 0 : long nLeftWidth = nSplitPos - pRowBar[SC_SPLIT_BOTTOM]->GetSizePixel().Width();
1563 0 : if ( nLeftWidth < 0 ) nLeftWidth = 0;
1564 : nNewDelta = nOldDelta + aViewData.CellsAtX( nOldDelta, 1, SC_SPLIT_LEFT,
1565 0 : (sal_uInt16) nLeftWidth );
1566 0 : if ( nNewDelta > MAXCOL )
1567 0 : nNewDelta = MAXCOL;
1568 0 : aViewData.SetPosX( SC_SPLIT_RIGHT, nNewDelta );
1569 0 : if ( nNewDelta > aViewData.GetCurX() )
1570 0 : ActivatePart( (WhichV(aViewData.GetActivePart()) == SC_SPLIT_BOTTOM) ?
1571 0 : SC_SPLIT_BOTTOMLEFT : SC_SPLIT_TOPLEFT );
1572 : else
1573 0 : ActivatePart( (WhichV(aViewData.GetActivePart()) == SC_SPLIT_BOTTOM) ?
1574 0 : SC_SPLIT_BOTTOMRIGHT : SC_SPLIT_TOPRIGHT );
1575 : }
1576 :
1577 : // Form-Layer muss den sichtbaren Ausschnitt aller Fenster kennen
1578 : // dafuer muss hier schon der MapMode stimmen
1579 0 : for (sal_uInt16 i=0; i<4; i++)
1580 0 : if (pGridWin[i])
1581 0 : pGridWin[i]->SetMapMode( pGridWin[i]->GetDrawMapMode() );
1582 0 : SetNewVisArea();
1583 :
1584 0 : PaintGrid();
1585 0 : PaintTop();
1586 :
1587 0 : InvalidateSplit();
1588 : }
1589 0 : }
1590 :
1591 0 : void ScTabView::DoVSplit(long nSplitPos)
1592 : {
1593 : long nMinPos;
1594 : long nMaxPos;
1595 : SCROW nOldDelta;
1596 : SCROW nNewDelta;
1597 :
1598 0 : nMinPos = SPLIT_MARGIN;
1599 0 : if ( pColBar[SC_SPLIT_LEFT] && pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height() >= nMinPos )
1600 0 : nMinPos = pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height() + 1;
1601 0 : nMaxPos = aFrameSize.Height() - SPLIT_MARGIN;
1602 :
1603 0 : ScSplitMode aOldMode = aViewData.GetVSplitMode();
1604 0 : ScSplitMode aNewMode = SC_SPLIT_NORMAL;
1605 :
1606 0 : aViewData.SetVSplitPos( nSplitPos );
1607 0 : if ( nSplitPos < nMinPos || nSplitPos > nMaxPos )
1608 0 : aNewMode = SC_SPLIT_NONE;
1609 :
1610 0 : aViewData.SetVSplitMode( aNewMode );
1611 :
1612 0 : if ( aNewMode != aOldMode )
1613 : {
1614 0 : UpdateShow(); // vor ActivatePart !!
1615 :
1616 0 : if ( aNewMode == SC_SPLIT_NONE )
1617 : {
1618 0 : nOldDelta = aViewData.GetPosY( SC_SPLIT_TOP );
1619 0 : aViewData.SetPosY( SC_SPLIT_BOTTOM, nOldDelta );
1620 :
1621 0 : if (aViewData.GetActivePart() == SC_SPLIT_TOPLEFT)
1622 0 : ActivatePart( SC_SPLIT_BOTTOMLEFT );
1623 0 : if (aViewData.GetActivePart() == SC_SPLIT_TOPRIGHT)
1624 0 : ActivatePart( SC_SPLIT_BOTTOMRIGHT );
1625 : }
1626 : else
1627 : {
1628 0 : if ( aOldMode == SC_SPLIT_NONE )
1629 0 : nOldDelta = aViewData.GetPosY( SC_SPLIT_BOTTOM );
1630 : else
1631 0 : nOldDelta = aViewData.GetPosY( SC_SPLIT_TOP );
1632 :
1633 0 : aViewData.SetPosY( SC_SPLIT_TOP, nOldDelta );
1634 0 : long nTopHeight = nSplitPos - pColBar[SC_SPLIT_LEFT]->GetSizePixel().Height();
1635 0 : if ( nTopHeight < 0 ) nTopHeight = 0;
1636 : nNewDelta = nOldDelta + aViewData.CellsAtY( nOldDelta, 1, SC_SPLIT_TOP,
1637 0 : (sal_uInt16) nTopHeight );
1638 0 : if ( nNewDelta > MAXROW )
1639 0 : nNewDelta = MAXROW;
1640 0 : aViewData.SetPosY( SC_SPLIT_BOTTOM, nNewDelta );
1641 0 : if ( nNewDelta > aViewData.GetCurY() )
1642 0 : ActivatePart( (WhichH(aViewData.GetActivePart()) == SC_SPLIT_LEFT) ?
1643 0 : SC_SPLIT_TOPLEFT : SC_SPLIT_TOPRIGHT );
1644 : else
1645 0 : ActivatePart( (WhichH(aViewData.GetActivePart()) == SC_SPLIT_LEFT) ?
1646 0 : SC_SPLIT_BOTTOMLEFT : SC_SPLIT_BOTTOMRIGHT );
1647 : }
1648 :
1649 : // Form-Layer muss den sichtbaren Ausschnitt aller Fenster kennen
1650 : // dafuer muss hier schon der MapMode stimmen
1651 0 : for (sal_uInt16 i=0; i<4; i++)
1652 0 : if (pGridWin[i])
1653 0 : pGridWin[i]->SetMapMode( pGridWin[i]->GetDrawMapMode() );
1654 0 : SetNewVisArea();
1655 :
1656 0 : PaintGrid();
1657 0 : PaintLeft();
1658 :
1659 0 : InvalidateSplit();
1660 : }
1661 0 : }
1662 :
1663 0 : Point ScTabView::GetInsertPos()
1664 : {
1665 0 : ScDocument* pDoc = aViewData.GetDocument();
1666 0 : SCCOL nCol = aViewData.GetCurX();
1667 0 : SCROW nRow = aViewData.GetCurY();
1668 0 : SCTAB nTab = aViewData.GetTabNo();
1669 0 : long nPosX = 0;
1670 0 : for (SCCOL i=0; i<nCol; i++)
1671 0 : nPosX += pDoc->GetColWidth(i,nTab);
1672 0 : nPosX = (long)(nPosX * HMM_PER_TWIPS);
1673 0 : if ( pDoc->IsNegativePage( nTab ) )
1674 0 : nPosX = -nPosX;
1675 0 : long nPosY = (long) pDoc->GetRowHeight( 0, nRow-1, nTab);
1676 0 : nPosY = (long)(nPosY * HMM_PER_TWIPS);
1677 0 : return Point(nPosX,nPosY);
1678 : }
1679 :
1680 0 : Point ScTabView::GetChartInsertPos( const Size& rSize, const ScRange& rCellRange )
1681 : {
1682 0 : Point aInsertPos;
1683 0 : const long nBorder = 100; // leave 1mm for border
1684 0 : long nNeededWidth = rSize.Width() + 2 * nBorder;
1685 0 : long nNeededHeight = rSize.Height() + 2 * nBorder;
1686 :
1687 : // use the active window, or lower/right if frozen (as in CalcZoom)
1688 0 : ScSplitPos eUsedPart = aViewData.GetActivePart();
1689 0 : if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
1690 0 : eUsedPart = (WhichV(eUsedPart)==SC_SPLIT_TOP) ? SC_SPLIT_TOPRIGHT : SC_SPLIT_BOTTOMRIGHT;
1691 0 : if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX )
1692 0 : eUsedPart = (WhichH(eUsedPart)==SC_SPLIT_LEFT) ? SC_SPLIT_BOTTOMLEFT : SC_SPLIT_BOTTOMRIGHT;
1693 :
1694 0 : ScGridWindow* pWin = pGridWin[eUsedPart];
1695 : OSL_ENSURE( pWin, "Window not found" );
1696 0 : if (pWin)
1697 : {
1698 0 : ActivatePart( eUsedPart );
1699 :
1700 : // get the visible rectangle in logic units
1701 :
1702 0 : MapMode aDrawMode = pWin->GetDrawMapMode();
1703 0 : Rectangle aVisible( pWin->PixelToLogic( Rectangle( Point(0,0), pWin->GetOutputSizePixel() ), aDrawMode ) );
1704 :
1705 0 : ScDocument* pDoc = aViewData.GetDocument();
1706 0 : SCTAB nTab = aViewData.GetTabNo();
1707 0 : sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
1708 0 : long nLayoutSign = bLayoutRTL ? -1 : 1;
1709 :
1710 0 : long nDocX = (long)( (double) pDoc->GetColOffset( MAXCOL + 1, nTab ) * HMM_PER_TWIPS ) * nLayoutSign;
1711 0 : long nDocY = (long)( (double) pDoc->GetRowOffset( MAXROW + 1, nTab ) * HMM_PER_TWIPS );
1712 :
1713 0 : if ( aVisible.Left() * nLayoutSign > nDocX * nLayoutSign )
1714 0 : aVisible.Left() = nDocX;
1715 0 : if ( aVisible.Right() * nLayoutSign > nDocX * nLayoutSign )
1716 0 : aVisible.Right() = nDocX;
1717 0 : if ( aVisible.Top() > nDocY )
1718 0 : aVisible.Top() = nDocY;
1719 0 : if ( aVisible.Bottom() > nDocY )
1720 0 : aVisible.Bottom() = nDocY;
1721 :
1722 : // get the logic position of the selection
1723 :
1724 0 : Rectangle aSelection = pDoc->GetMMRect( rCellRange.aStart.Col(), rCellRange.aStart.Row(),
1725 0 : rCellRange.aEnd.Col(), rCellRange.aEnd.Row(), nTab );
1726 :
1727 0 : long nLeftSpace = aSelection.Left() - aVisible.Left();
1728 0 : long nRightSpace = aVisible.Right() - aSelection.Right();
1729 0 : long nTopSpace = aSelection.Top() - aVisible.Top();
1730 0 : long nBottomSpace = aVisible.Bottom() - aSelection.Bottom();
1731 :
1732 0 : bool bFitLeft = ( nLeftSpace >= nNeededWidth );
1733 0 : bool bFitRight = ( nRightSpace >= nNeededWidth );
1734 :
1735 0 : if ( bFitLeft || bFitRight )
1736 : {
1737 : // first preference: completely left or right of the selection
1738 :
1739 : // if both fit, prefer left in RTL mode, right otherwise
1740 0 : bool bPutLeft = bFitLeft && ( bLayoutRTL || !bFitRight );
1741 :
1742 0 : if ( bPutLeft )
1743 0 : aInsertPos.X() = aSelection.Left() - nNeededWidth;
1744 : else
1745 0 : aInsertPos.X() = aSelection.Right() + 1;
1746 :
1747 : // align with top of selection (is moved again if it doesn't fit)
1748 0 : aInsertPos.Y() = std::max( aSelection.Top(), aVisible.Top() );
1749 : }
1750 0 : else if ( nTopSpace >= nNeededHeight || nBottomSpace >= nNeededHeight )
1751 : {
1752 : // second preference: completely above or below the selection
1753 :
1754 0 : if ( nBottomSpace > nNeededHeight ) // bottom is preferred
1755 0 : aInsertPos.Y() = aSelection.Bottom() + 1;
1756 : else
1757 0 : aInsertPos.Y() = aSelection.Top() - nNeededHeight;
1758 :
1759 : // align with (logic) left edge of selection (moved again if it doesn't fit)
1760 0 : if ( bLayoutRTL )
1761 0 : aInsertPos.X() = std::min( aSelection.Right(), aVisible.Right() ) - nNeededWidth + 1;
1762 : else
1763 0 : aInsertPos.X() = std::max( aSelection.Left(), aVisible.Left() );
1764 : }
1765 : else
1766 : {
1767 : // place to the (logic) right of the selection and move so it fits
1768 :
1769 0 : if ( bLayoutRTL )
1770 0 : aInsertPos.X() = aSelection.Left() - nNeededWidth;
1771 : else
1772 0 : aInsertPos.X() = aSelection.Right() + 1;
1773 0 : aInsertPos.Y() = std::max( aSelection.Top(), aVisible.Top() );
1774 : }
1775 :
1776 : // move the position if the object doesn't fit in the screen
1777 :
1778 0 : Rectangle aCompareRect( aInsertPos, Size( nNeededWidth, nNeededHeight ) );
1779 0 : if ( aCompareRect.Right() > aVisible.Right() )
1780 0 : aInsertPos.X() -= aCompareRect.Right() - aVisible.Right();
1781 0 : if ( aCompareRect.Bottom() > aVisible.Bottom() )
1782 0 : aInsertPos.Y() -= aCompareRect.Bottom() - aVisible.Bottom();
1783 :
1784 0 : if ( aInsertPos.X() < aVisible.Left() )
1785 0 : aInsertPos.X() = aVisible.Left();
1786 0 : if ( aInsertPos.Y() < aVisible.Top() )
1787 0 : aInsertPos.Y() = aVisible.Top();
1788 :
1789 : // nNeededWidth / nNeededHeight includes all borders - move aInsertPos to the
1790 : // object position, inside the border
1791 :
1792 0 : aInsertPos.X() += nBorder;
1793 0 : aInsertPos.Y() += nBorder;
1794 : }
1795 0 : return aInsertPos;
1796 : }
1797 :
1798 0 : Point ScTabView::GetChartDialogPos( const Size& rDialogSize, const Rectangle& rLogicChart )
1799 : {
1800 : // rDialogSize must be in pixels, rLogicChart in 1/100 mm. Return value is in pixels.
1801 :
1802 0 : Point aRet;
1803 :
1804 : // use the active window, or lower/right if frozen (as in CalcZoom)
1805 0 : ScSplitPos eUsedPart = aViewData.GetActivePart();
1806 0 : if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
1807 0 : eUsedPart = (WhichV(eUsedPart)==SC_SPLIT_TOP) ? SC_SPLIT_TOPRIGHT : SC_SPLIT_BOTTOMRIGHT;
1808 0 : if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX )
1809 0 : eUsedPart = (WhichH(eUsedPart)==SC_SPLIT_LEFT) ? SC_SPLIT_BOTTOMLEFT : SC_SPLIT_BOTTOMRIGHT;
1810 :
1811 0 : ScGridWindow* pWin = pGridWin[eUsedPart];
1812 : OSL_ENSURE( pWin, "Window not found" );
1813 0 : if (pWin)
1814 : {
1815 0 : MapMode aDrawMode = pWin->GetDrawMapMode();
1816 0 : Rectangle aObjPixel = pWin->LogicToPixel( rLogicChart, aDrawMode );
1817 0 : Rectangle aObjAbs( pWin->OutputToAbsoluteScreenPixel( aObjPixel.TopLeft() ),
1818 0 : pWin->OutputToAbsoluteScreenPixel( aObjPixel.BottomRight() ) );
1819 :
1820 0 : Rectangle aDesktop = pWin->GetDesktopRectPixel();
1821 0 : Size aSpace = pWin->LogicToPixel( Size( 8, 12 ), MAP_APPFONT );
1822 :
1823 0 : ScDocument* pDoc = aViewData.GetDocument();
1824 0 : SCTAB nTab = aViewData.GetTabNo();
1825 0 : sal_Bool bLayoutRTL = pDoc->IsLayoutRTL( nTab );
1826 :
1827 0 : bool bCenterHor = false;
1828 :
1829 0 : if ( aDesktop.Bottom() - aObjAbs.Bottom() >= rDialogSize.Height() + aSpace.Height() )
1830 : {
1831 : // first preference: below the chart
1832 :
1833 0 : aRet.Y() = aObjAbs.Bottom() + aSpace.Height();
1834 0 : bCenterHor = true;
1835 : }
1836 0 : else if ( aObjAbs.Top() - aDesktop.Top() >= rDialogSize.Height() + aSpace.Height() )
1837 : {
1838 : // second preference: above the chart
1839 :
1840 0 : aRet.Y() = aObjAbs.Top() - rDialogSize.Height() - aSpace.Height();
1841 0 : bCenterHor = true;
1842 : }
1843 : else
1844 : {
1845 0 : bool bFitLeft = ( aObjAbs.Left() - aDesktop.Left() >= rDialogSize.Width() + aSpace.Width() );
1846 0 : bool bFitRight = ( aDesktop.Right() - aObjAbs.Right() >= rDialogSize.Width() + aSpace.Width() );
1847 :
1848 0 : if ( bFitLeft || bFitRight )
1849 : {
1850 : // if both fit, prefer right in RTL mode, left otherwise
1851 0 : bool bPutRight = bFitRight && ( bLayoutRTL || !bFitLeft );
1852 0 : if ( bPutRight )
1853 0 : aRet.X() = aObjAbs.Right() + aSpace.Width();
1854 : else
1855 0 : aRet.X() = aObjAbs.Left() - rDialogSize.Width() - aSpace.Width();
1856 :
1857 : // center vertically
1858 0 : aRet.Y() = aObjAbs.Top() + ( aObjAbs.GetHeight() - rDialogSize.Height() ) / 2;
1859 : }
1860 : else
1861 : {
1862 : // doesn't fit on any edge - put at the bottom of the screen
1863 0 : aRet.Y() = aDesktop.Bottom() - rDialogSize.Height();
1864 0 : bCenterHor = true;
1865 : }
1866 : }
1867 0 : if ( bCenterHor )
1868 0 : aRet.X() = aObjAbs.Left() + ( aObjAbs.GetWidth() - rDialogSize.Width() ) / 2;
1869 :
1870 : // limit to screen (centering might lead to invalid positions)
1871 0 : if ( aRet.X() + rDialogSize.Width() - 1 > aDesktop.Right() )
1872 0 : aRet.X() = aDesktop.Right() - rDialogSize.Width() + 1;
1873 0 : if ( aRet.X() < aDesktop.Left() )
1874 0 : aRet.X() = aDesktop.Left();
1875 0 : if ( aRet.Y() + rDialogSize.Height() - 1 > aDesktop.Bottom() )
1876 0 : aRet.Y() = aDesktop.Bottom() - rDialogSize.Height() + 1;
1877 0 : if ( aRet.Y() < aDesktop.Top() )
1878 0 : aRet.Y() = aDesktop.Top();
1879 : }
1880 :
1881 0 : return aRet;
1882 : }
1883 :
1884 0 : void ScTabView::LockModifiers( sal_uInt16 nModifiers )
1885 : {
1886 0 : pSelEngine->LockModifiers( nModifiers );
1887 0 : pHdrSelEng->LockModifiers( nModifiers );
1888 0 : }
1889 :
1890 0 : sal_uInt16 ScTabView::GetLockedModifiers() const
1891 : {
1892 0 : return pSelEngine->GetLockedModifiers();
1893 : }
1894 :
1895 0 : Point ScTabView::GetMousePosPixel()
1896 : {
1897 0 : Point aPos;
1898 0 : ScGridWindow* pWin = (ScGridWindow*)GetActiveWin();
1899 :
1900 0 : if ( pWin )
1901 0 : aPos = pWin->GetMousePosPixel();
1902 :
1903 0 : return aPos;
1904 : }
1905 :
1906 0 : static sal_Bool lcl_MouseIsOverWin( const Point& rScreenPosPixel, Window* pWin )
1907 : {
1908 0 : if (pWin)
1909 : {
1910 : // SPLIT_HANDLE_SIZE draufaddieren, damit das Einrasten genau
1911 : // auf dem Splitter nicht aussetzt
1912 :
1913 0 : Point aRel = pWin->NormalizedScreenToOutputPixel( rScreenPosPixel );
1914 0 : Size aWinSize = pWin->GetOutputSizePixel();
1915 0 : if ( aRel.X() >= 0 && aRel.X() < aWinSize.Width() + SPLIT_HANDLE_SIZE &&
1916 0 : aRel.Y() >= 0 && aRel.Y() < aWinSize.Height() + SPLIT_HANDLE_SIZE )
1917 0 : return sal_True;
1918 : }
1919 0 : return false;
1920 : }
1921 :
1922 0 : void ScTabView::SnapSplitPos( Point& rScreenPosPixel )
1923 : {
1924 0 : sal_Bool bOverWin = false;
1925 : sal_uInt16 i;
1926 0 : for (i=0; i<4; i++)
1927 0 : if (lcl_MouseIsOverWin(rScreenPosPixel,pGridWin[i]))
1928 0 : bOverWin = sal_True;
1929 :
1930 0 : if (!bOverWin)
1931 0 : return;
1932 :
1933 : // don't snap to cells if the scale will be modified afterwards
1934 0 : if ( GetZoomType() != SVX_ZOOM_PERCENT )
1935 0 : return;
1936 :
1937 0 : ScSplitPos ePos = SC_SPLIT_BOTTOMLEFT;
1938 0 : if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
1939 0 : ePos = SC_SPLIT_TOPLEFT;
1940 :
1941 0 : Window* pWin = pGridWin[ePos];
1942 0 : if (!pWin)
1943 : {
1944 : OSL_FAIL("Window NULL");
1945 0 : return;
1946 : }
1947 :
1948 0 : Point aMouse = pWin->NormalizedScreenToOutputPixel( rScreenPosPixel );
1949 : SCsCOL nPosX;
1950 : SCsROW nPosY;
1951 : // bNextIfLarge=FALSE: nicht auf naechste Zelle, wenn ausserhalb des Fensters
1952 0 : aViewData.GetPosFromPixel( aMouse.X(), aMouse.Y(), ePos, nPosX, nPosY, true, false, false );
1953 : bool bLeft;
1954 : bool bTop;
1955 0 : aViewData.GetMouseQuadrant( aMouse, ePos, nPosX, nPosY, bLeft, bTop );
1956 0 : if (!bLeft)
1957 0 : ++nPosX;
1958 0 : if (!bTop)
1959 0 : ++nPosY;
1960 0 : aMouse = aViewData.GetScrPos( static_cast<SCCOL>(nPosX), static_cast<SCROW>(nPosY), ePos, true );
1961 0 : rScreenPosPixel = pWin->OutputToNormalizedScreenPixel( aMouse );
1962 : }
1963 :
1964 0 : void ScTabView::FreezeSplitters( bool bFreeze )
1965 : {
1966 0 : ScSplitMode eOldH = aViewData.GetHSplitMode();
1967 0 : ScSplitMode eOldV = aViewData.GetVSplitMode();
1968 :
1969 0 : ScSplitPos ePos = SC_SPLIT_BOTTOMLEFT;
1970 0 : if ( eOldV != SC_SPLIT_NONE )
1971 0 : ePos = SC_SPLIT_TOPLEFT;
1972 0 : Window* pWin = pGridWin[ePos];
1973 :
1974 0 : bool bLayoutRTL = aViewData.GetDocument()->IsLayoutRTL( aViewData.GetTabNo() );
1975 :
1976 0 : if ( bFreeze )
1977 : {
1978 0 : Point aWinStart = pWin->GetPosPixel();
1979 0 : aViewData.GetDocShell()->SetDocumentModified();
1980 :
1981 0 : Point aSplit;
1982 : SCsCOL nPosX;
1983 : SCsROW nPosY;
1984 0 : if (eOldH != SC_SPLIT_NONE || eOldV != SC_SPLIT_NONE)
1985 : {
1986 0 : if (eOldH != SC_SPLIT_NONE)
1987 : {
1988 0 : long nSplitPos = aViewData.GetHSplitPos();
1989 0 : if ( bLayoutRTL )
1990 0 : nSplitPos = pFrameWin->GetOutputSizePixel().Width() - nSplitPos - 1;
1991 0 : aSplit.X() = nSplitPos - aWinStart.X();
1992 : }
1993 0 : if (eOldV != SC_SPLIT_NONE)
1994 0 : aSplit.Y() = aViewData.GetVSplitPos() - aWinStart.Y();
1995 :
1996 0 : aViewData.GetPosFromPixel( aSplit.X(), aSplit.Y(), ePos, nPosX, nPosY );
1997 : bool bLeft;
1998 : bool bTop;
1999 0 : aViewData.GetMouseQuadrant( aSplit, ePos, nPosX, nPosY, bLeft, bTop );
2000 0 : if (!bLeft)
2001 0 : ++nPosX;
2002 0 : if (!bTop)
2003 0 : ++nPosY;
2004 : }
2005 : else
2006 : {
2007 0 : nPosX = static_cast<SCsCOL>( aViewData.GetCurX());
2008 0 : nPosY = static_cast<SCsROW>( aViewData.GetCurY());
2009 : }
2010 :
2011 0 : SCCOL nLeftPos = aViewData.GetPosX(SC_SPLIT_LEFT);
2012 0 : SCROW nTopPos = aViewData.GetPosY(SC_SPLIT_BOTTOM);
2013 0 : SCCOL nRightPos = static_cast<SCCOL>(nPosX);
2014 0 : SCROW nBottomPos = static_cast<SCROW>(nPosY);
2015 0 : if (eOldH != SC_SPLIT_NONE)
2016 0 : if (aViewData.GetPosX(SC_SPLIT_RIGHT) > nRightPos)
2017 0 : nRightPos = aViewData.GetPosX(SC_SPLIT_RIGHT);
2018 0 : if (eOldV != SC_SPLIT_NONE)
2019 : {
2020 0 : nTopPos = aViewData.GetPosY(SC_SPLIT_TOP);
2021 0 : if (aViewData.GetPosY(SC_SPLIT_BOTTOM) > nBottomPos)
2022 0 : nBottomPos = aViewData.GetPosY(SC_SPLIT_BOTTOM);
2023 : }
2024 :
2025 0 : aSplit = aViewData.GetScrPos( static_cast<SCCOL>(nPosX), static_cast<SCROW>(nPosY), ePos, true );
2026 0 : if (nPosX > aViewData.GetPosX(SC_SPLIT_LEFT)) // (aSplit.X() > 0) doesn't work for RTL
2027 : {
2028 0 : long nSplitPos = aSplit.X() + aWinStart.X();
2029 0 : if ( bLayoutRTL )
2030 0 : nSplitPos = pFrameWin->GetOutputSizePixel().Width() - nSplitPos - 1;
2031 :
2032 0 : aViewData.SetHSplitMode( SC_SPLIT_FIX );
2033 0 : aViewData.SetHSplitPos( nSplitPos );
2034 0 : aViewData.SetFixPosX( nPosX );
2035 :
2036 0 : aViewData.SetPosX(SC_SPLIT_LEFT, nLeftPos);
2037 0 : aViewData.SetPosX(SC_SPLIT_RIGHT, nRightPos);
2038 : }
2039 : else
2040 0 : aViewData.SetHSplitMode( SC_SPLIT_NONE );
2041 0 : if (aSplit.Y() > 0)
2042 : {
2043 0 : aViewData.SetVSplitMode( SC_SPLIT_FIX );
2044 0 : aViewData.SetVSplitPos( aSplit.Y() + aWinStart.Y() );
2045 0 : aViewData.SetFixPosY( nPosY );
2046 :
2047 0 : aViewData.SetPosY(SC_SPLIT_TOP, nTopPos);
2048 0 : aViewData.SetPosY(SC_SPLIT_BOTTOM, nBottomPos);
2049 : }
2050 : else
2051 0 : aViewData.SetVSplitMode( SC_SPLIT_NONE );
2052 : }
2053 : else // Fixierung aufheben
2054 : {
2055 0 : if ( eOldH == SC_SPLIT_FIX )
2056 0 : aViewData.SetHSplitMode( SC_SPLIT_NORMAL );
2057 0 : if ( eOldV == SC_SPLIT_FIX )
2058 0 : aViewData.SetVSplitMode( SC_SPLIT_NORMAL );
2059 : }
2060 :
2061 : // Form-Layer muss den sichtbaren Ausschnitt aller Fenster kennen
2062 : // dafuer muss hier schon der MapMode stimmen
2063 0 : for (sal_uInt16 i=0; i<4; i++)
2064 0 : if (pGridWin[i])
2065 0 : pGridWin[i]->SetMapMode( pGridWin[i]->GetDrawMapMode() );
2066 0 : SetNewVisArea();
2067 :
2068 0 : RepeatResize(false);
2069 :
2070 0 : UpdateShow();
2071 0 : PaintLeft();
2072 0 : PaintTop();
2073 0 : PaintGrid();
2074 :
2075 : // SC_FOLLOW_NONE: only update active part
2076 0 : AlignToCursor( aViewData.GetCurX(), aViewData.GetCurY(), SC_FOLLOW_NONE );
2077 0 : UpdateAutoFillMark();
2078 :
2079 0 : InvalidateSplit();
2080 0 : }
2081 :
2082 0 : void ScTabView::RemoveSplit()
2083 : {
2084 0 : DoHSplit( 0 );
2085 0 : DoVSplit( 0 );
2086 0 : RepeatResize();
2087 0 : }
2088 :
2089 0 : void ScTabView::SplitAtCursor()
2090 : {
2091 0 : ScSplitPos ePos = SC_SPLIT_BOTTOMLEFT;
2092 0 : if ( aViewData.GetVSplitMode() != SC_SPLIT_NONE )
2093 0 : ePos = SC_SPLIT_TOPLEFT;
2094 0 : Window* pWin = pGridWin[ePos];
2095 0 : Point aWinStart = pWin->GetPosPixel();
2096 :
2097 0 : SCCOL nPosX = aViewData.GetCurX();
2098 0 : SCROW nPosY = aViewData.GetCurY();
2099 0 : Point aSplit = aViewData.GetScrPos( nPosX, nPosY, ePos, true );
2100 0 : if ( nPosX > 0 )
2101 0 : DoHSplit( aSplit.X() + aWinStart.X() );
2102 : else
2103 0 : DoHSplit( 0 );
2104 0 : if ( nPosY > 0 )
2105 0 : DoVSplit( aSplit.Y() + aWinStart.Y() );
2106 : else
2107 0 : DoVSplit( 0 );
2108 0 : RepeatResize();
2109 0 : }
2110 :
2111 0 : void ScTabView::SplitAtPixel( const Point& rPixel, bool bHor, bool bVer )
2112 : {
2113 : // Pixel ist auf die ganze View bezogen, nicht auf das erste GridWin
2114 :
2115 0 : if (bHor)
2116 : {
2117 0 : if ( rPixel.X() > 0 )
2118 0 : DoHSplit( rPixel.X() );
2119 : else
2120 0 : DoHSplit( 0 );
2121 : }
2122 0 : if (bVer)
2123 : {
2124 0 : if ( rPixel.Y() > 0 )
2125 0 : DoVSplit( rPixel.Y() );
2126 : else
2127 0 : DoVSplit( 0 );
2128 : }
2129 0 : RepeatResize();
2130 0 : }
2131 :
2132 0 : void ScTabView::InvalidateSplit()
2133 : {
2134 0 : SfxBindings& rBindings = aViewData.GetBindings();
2135 0 : rBindings.Invalidate( SID_WINDOW_SPLIT );
2136 0 : rBindings.Invalidate( SID_WINDOW_FIX );
2137 :
2138 0 : pHSplitter->SetFixed( aViewData.GetHSplitMode() == SC_SPLIT_FIX );
2139 0 : pVSplitter->SetFixed( aViewData.GetVSplitMode() == SC_SPLIT_FIX );
2140 0 : }
2141 :
2142 0 : void ScTabView::SetNewVisArea()
2143 : {
2144 : // fuer die Controls muss bei VisAreaChanged der Draw-MapMode eingestellt sein
2145 : // (auch wenn ansonsten der Edit-MapMode gesetzt ist)
2146 0 : MapMode aOldMode[4];
2147 0 : MapMode aDrawMode[4];
2148 : sal_uInt16 i;
2149 0 : for (i=0; i<4; i++)
2150 0 : if (pGridWin[i])
2151 : {
2152 0 : aOldMode[i] = pGridWin[i]->GetMapMode();
2153 0 : aDrawMode[i] = pGridWin[i]->GetDrawMapMode();
2154 0 : if (aDrawMode[i] != aOldMode[i])
2155 0 : pGridWin[i]->SetMapMode(aDrawMode[i]);
2156 : }
2157 :
2158 0 : Window* pActive = pGridWin[aViewData.GetActivePart()];
2159 0 : if (pActive)
2160 0 : aViewData.GetViewShell()->VisAreaChanged(
2161 0 : pActive->PixelToLogic(Rectangle(Point(),pActive->GetOutputSizePixel())) );
2162 0 : if (pDrawView)
2163 0 : pDrawView->VisAreaChanged(); // kein Window uebergeben -> alle Fenster
2164 :
2165 0 : UpdateAllOverlays(); // #i79909# with drawing MapMode set
2166 :
2167 0 : for (i=0; i<4; i++)
2168 0 : if (pGridWin[i] && aDrawMode[i] != aOldMode[i])
2169 : {
2170 0 : pGridWin[i]->flushOverlayManager(); // #i79909# flush overlays before switching to edit MapMode
2171 0 : pGridWin[i]->SetMapMode(aOldMode[i]);
2172 : }
2173 :
2174 0 : SfxViewFrame* pViewFrame = aViewData.GetViewShell()->GetViewFrame();
2175 0 : if (pViewFrame)
2176 : {
2177 0 : SfxFrame& rFrame = pViewFrame->GetFrame();
2178 0 : com::sun::star::uno::Reference<com::sun::star::frame::XController> xController = rFrame.GetController();
2179 0 : if (xController.is())
2180 : {
2181 0 : ScTabViewObj* pImp = ScTabViewObj::getImplementation( xController );
2182 0 : if (pImp)
2183 0 : pImp->VisAreaChanged();
2184 0 : }
2185 : }
2186 0 : if (aViewData.GetViewShell()->HasAccessibilityObjects())
2187 0 : aViewData.GetViewShell()->BroadcastAccessibility(SfxSimpleHint(SC_HINT_ACC_VISAREACHANGED));
2188 0 : }
2189 :
2190 0 : bool ScTabView::HasPageFieldDataAtCursor() const
2191 : {
2192 0 : ScGridWindow* pWin = pGridWin[aViewData.GetActivePart()];
2193 0 : SCCOL nCol = aViewData.GetCurX();
2194 0 : SCROW nRow = aViewData.GetCurY();
2195 0 : if (pWin)
2196 0 : return pWin->GetDPFieldOrientation( nCol, nRow ) == sheet::DataPilotFieldOrientation_PAGE;
2197 :
2198 0 : return false;
2199 : }
2200 :
2201 0 : void ScTabView::StartDataSelect()
2202 : {
2203 0 : ScGridWindow* pWin = pGridWin[aViewData.GetActivePart()];
2204 0 : SCCOL nCol = aViewData.GetCurX();
2205 0 : SCROW nRow = aViewData.GetCurY();
2206 :
2207 0 : if (!pWin)
2208 0 : return;
2209 :
2210 0 : switch (pWin->GetDPFieldOrientation(nCol, nRow))
2211 : {
2212 : case sheet::DataPilotFieldOrientation_PAGE:
2213 : // #i36598# If the cursor is on a page field's data cell,
2214 : // no meaningful input is possible anyway, so this function
2215 : // can be used to select a page field entry.
2216 0 : pWin->LaunchPageFieldMenu( nCol, nRow );
2217 0 : return;
2218 : case sheet::DataPilotFieldOrientation_COLUMN:
2219 : case sheet::DataPilotFieldOrientation_ROW:
2220 0 : pWin->LaunchDPFieldMenu( nCol, nRow );
2221 0 : return;
2222 : default:
2223 : ;
2224 : }
2225 :
2226 : // Do autofilter if the current cell has autofilter button. Otherwise do
2227 : // a normal data select popup.
2228 : const ScMergeFlagAttr* pAttr = static_cast<const ScMergeFlagAttr*>(
2229 : aViewData.GetDocument()->GetAttr(
2230 0 : nCol, nRow, aViewData.GetTabNo(), ATTR_MERGE_FLAG));
2231 :
2232 0 : if (pAttr->HasAutoFilter())
2233 0 : pWin->LaunchAutoFilterMenu(nCol, nRow);
2234 : else
2235 0 : pWin->LaunchDataSelectMenu(nCol, nRow, true);
2236 : }
2237 :
2238 0 : void ScTabView::EnableRefInput(bool bFlag)
2239 : {
2240 0 : aHScrollLeft.EnableInput(bFlag);
2241 0 : aHScrollRight.EnableInput(bFlag);
2242 0 : aVScrollBottom.EnableInput(bFlag);
2243 0 : aVScrollTop.EnableInput(bFlag);
2244 0 : aScrollBarBox.EnableInput(bFlag);
2245 :
2246 : // ab hier dynamisch angelegte
2247 :
2248 0 : if(pTabControl!=NULL) pTabControl->EnableInput(bFlag,true);
2249 :
2250 0 : if(pGridWin[SC_SPLIT_BOTTOMLEFT]!=NULL)
2251 0 : pGridWin[SC_SPLIT_BOTTOMLEFT]->EnableInput(bFlag,false);
2252 0 : if(pGridWin[SC_SPLIT_BOTTOMRIGHT]!=NULL)
2253 0 : pGridWin[SC_SPLIT_BOTTOMRIGHT]->EnableInput(bFlag,false);
2254 0 : if(pGridWin[SC_SPLIT_TOPLEFT]!=NULL)
2255 0 : pGridWin[SC_SPLIT_TOPLEFT]->EnableInput(bFlag,false);
2256 0 : if(pGridWin[SC_SPLIT_TOPRIGHT]!=NULL)
2257 0 : pGridWin[SC_SPLIT_TOPRIGHT]->EnableInput(bFlag,false);
2258 0 : if(pColBar[SC_SPLIT_RIGHT]!=NULL)
2259 0 : pColBar[SC_SPLIT_RIGHT]->EnableInput(bFlag,false);
2260 0 : if(pRowBar[SC_SPLIT_TOP]!=NULL)
2261 0 : pRowBar[SC_SPLIT_TOP]->EnableInput(bFlag,false);
2262 0 : }
2263 :
2264 0 : void ScTabView::SetInRefMode( bool bRefMode )
2265 : {
2266 0 : if(pGridWin[SC_SPLIT_BOTTOMLEFT])
2267 0 : pGridWin[SC_SPLIT_BOTTOMLEFT]->SetInRefMode( bRefMode );
2268 0 : if(pGridWin[SC_SPLIT_BOTTOMRIGHT])
2269 0 : pGridWin[SC_SPLIT_BOTTOMRIGHT]->SetInRefMode( bRefMode );
2270 0 : if(pGridWin[SC_SPLIT_TOPLEFT])
2271 0 : pGridWin[SC_SPLIT_TOPLEFT]->SetInRefMode( bRefMode );
2272 0 : if(pGridWin[SC_SPLIT_TOPRIGHT])
2273 0 : pGridWin[SC_SPLIT_TOPRIGHT]->SetInRefMode( bRefMode );
2274 0 : }
2275 :
2276 0 : bool ScTabView::ContinueOnlineSpelling()
2277 : {
2278 0 : bool bChanged = false;
2279 0 : for (int i = 0; i < 4; ++i)
2280 : {
2281 0 : if (!pGridWin[i] || !pGridWin[i]->IsVisible())
2282 0 : continue;
2283 :
2284 0 : if (pGridWin[i]->ContinueOnlineSpelling())
2285 0 : bChanged = true;
2286 : }
2287 :
2288 0 : return bChanged;
2289 : }
2290 :
2291 0 : void ScTabView::EnableAutoSpell( bool bEnable )
2292 : {
2293 0 : for (int i = 0; i < 4; ++i)
2294 : {
2295 0 : if (!pGridWin[i])
2296 0 : continue;
2297 :
2298 0 : pGridWin[i]->EnableAutoSpell(bEnable);
2299 : }
2300 0 : }
2301 :
2302 0 : void ScTabView::ResetAutoSpell()
2303 : {
2304 0 : for (int i = 0; i < 4; ++i)
2305 : {
2306 0 : if (!pGridWin[i])
2307 0 : continue;
2308 :
2309 0 : pGridWin[i]->ResetAutoSpell();
2310 : }
2311 0 : }
2312 :
2313 0 : void ScTabView::SetAutoSpellData( SCCOL nPosX, SCROW nPosY, const std::vector<editeng::MisspellRanges>* pRanges )
2314 : {
2315 0 : for (int i = 0; i < 4; ++i)
2316 : {
2317 0 : if (!pGridWin[i])
2318 0 : continue;
2319 :
2320 0 : pGridWin[i]->SetAutoSpellData(nPosX, nPosY, pRanges);
2321 : }
2322 0 : }
2323 :
2324 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
