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 <rangelst.hxx>
21 : #include "scitems.hxx"
22 : #include <editeng/eeitem.hxx>
23 :
24 :
25 : #include <editeng/brushitem.hxx>
26 : #include <editeng/editview.hxx>
27 : #include <svx/fmshell.hxx>
28 : #include <svx/svdoole2.hxx>
29 : #include <sfx2/bindings.hxx>
30 : #include <sfx2/viewfrm.hxx>
31 : #include <vcl/cursor.hxx>
32 :
33 : #include "tabview.hxx"
34 : #include "tabvwsh.hxx"
35 : #include "docsh.hxx"
36 : #include "gridwin.hxx"
37 : #include "olinewin.hxx"
38 : #include "colrowba.hxx"
39 : #include "tabcont.hxx"
40 : #include "scmod.hxx"
41 : #include "uiitems.hxx"
42 : #include "sc.hrc"
43 : #include "viewutil.hxx"
44 : #include "editutil.hxx"
45 : #include "inputhdl.hxx"
46 : #include "inputwin.hxx"
47 : #include "validat.hxx"
48 : #include "hintwin.hxx"
49 : #include "inputopt.hxx"
50 : #include "rfindlst.hxx"
51 : #include "hiranges.hxx"
52 : #include "viewuno.hxx"
53 : #include "chartarr.hxx"
54 : #include "anyrefdg.hxx"
55 : #include "dpobject.hxx"
56 : #include "patattr.hxx"
57 : #include "dociter.hxx"
58 : #include "seltrans.hxx"
59 : #include "fillinfo.hxx"
60 : #include "AccessibilityHints.hxx"
61 : #include "rangeutl.hxx"
62 : #include "client.hxx"
63 : #include "tabprotection.hxx"
64 : #include "markdata.hxx"
65 : #include "formula/FormulaCompiler.hxx"
66 :
67 : #include <com/sun/star/chart2/data/HighlightedRange.hpp>
68 :
69 : namespace
70 : {
71 :
72 0 : ScRange lcl_getSubRangeByIndex( const ScRange& rRange, sal_Int32 nIndex )
73 : {
74 0 : ScAddress aResult( rRange.aStart );
75 :
76 0 : SCCOL nWidth = rRange.aEnd.Col() - rRange.aStart.Col() + 1;
77 0 : SCROW nHeight = rRange.aEnd.Row() - rRange.aStart.Row() + 1;
78 0 : SCTAB nDepth = rRange.aEnd.Tab() - rRange.aStart.Tab() + 1;
79 0 : if( (nWidth > 0) && (nHeight > 0) && (nDepth > 0) )
80 : {
81 : // row by row from first to last sheet
82 0 : sal_Int32 nArea = nWidth * nHeight;
83 0 : aResult.IncCol( static_cast< SCsCOL >( nIndex % nWidth ) );
84 0 : aResult.IncRow( static_cast< SCsROW >( (nIndex % nArea) / nWidth ) );
85 0 : aResult.IncTab( static_cast< SCsTAB >( nIndex / nArea ) );
86 0 : if( !rRange.In( aResult ) )
87 0 : aResult = rRange.aStart;
88 : }
89 :
90 0 : return ScRange( aResult );
91 : }
92 :
93 : } // anonymous namespace
94 :
95 : using namespace com::sun::star;
96 :
97 :
98 : // --- Public-Funktionen
99 :
100 :
101 0 : void ScTabView::ClickCursor( SCCOL nPosX, SCROW nPosY, bool bControl )
102 : {
103 0 : ScDocument* pDoc = aViewData.GetDocument();
104 0 : SCTAB nTab = aViewData.GetTabNo();
105 0 : pDoc->SkipOverlapped(nPosX, nPosY, nTab);
106 :
107 0 : bool bRefMode = SC_MOD()->IsFormulaMode();
108 :
109 0 : if ( bRefMode )
110 : {
111 0 : DoneRefMode( false );
112 :
113 0 : if (bControl)
114 0 : SC_MOD()->AddRefEntry();
115 :
116 0 : InitRefMode( nPosX, nPosY, nTab, SC_REFTYPE_REF );
117 : }
118 : else
119 : {
120 0 : DoneBlockMode( bControl );
121 0 : aViewData.ResetOldCursor();
122 0 : SetCursor( (SCCOL) nPosX, (SCROW) nPosY );
123 : }
124 0 : }
125 :
126 0 : void ScTabView::UpdateAutoFillMark()
127 : {
128 : // single selection or cursor
129 0 : ScRange aMarkRange;
130 0 : bool bMarked = (aViewData.GetSimpleArea( aMarkRange ) == SC_MARK_SIMPLE);
131 :
132 : sal_uInt16 i;
133 0 : for (i=0; i<4; i++)
134 0 : if (pGridWin[i] && pGridWin[i]->IsVisible())
135 0 : pGridWin[i]->UpdateAutoFillMark( bMarked, aMarkRange );
136 :
137 0 : for (i=0; i<2; i++)
138 : {
139 0 : if (pColBar[i] && pColBar[i]->IsVisible())
140 0 : pColBar[i]->SetMark( bMarked, aMarkRange.aStart.Col(), aMarkRange.aEnd.Col() );
141 0 : if (pRowBar[i] && pRowBar[i]->IsVisible())
142 0 : pRowBar[i]->SetMark( bMarked, aMarkRange.aStart.Row(), aMarkRange.aEnd.Row() );
143 : }
144 :
145 : // selection transfer object is checked together with AutoFill marks,
146 : // because it has the same requirement of a single continuous block.
147 0 : CheckSelectionTransfer(); // update selection transfer object
148 0 : }
149 :
150 0 : void ScTabView::FakeButtonUp( ScSplitPos eWhich )
151 : {
152 0 : if (pGridWin[eWhich])
153 0 : pGridWin[eWhich]->FakeButtonUp();
154 0 : }
155 :
156 0 : void ScTabView::HideAllCursors()
157 : {
158 0 : for (sal_uInt16 i=0; i<4; i++)
159 0 : if (pGridWin[i])
160 0 : if (pGridWin[i]->IsVisible())
161 : {
162 0 : Cursor* pCur = pGridWin[i]->GetCursor();
163 0 : if (pCur)
164 0 : if (pCur->IsVisible())
165 0 : pCur->Hide();
166 0 : pGridWin[i]->HideCursor();
167 : }
168 0 : }
169 :
170 0 : void ScTabView::ShowAllCursors()
171 : {
172 0 : for (sal_uInt16 i=0; i<4; i++)
173 0 : if (pGridWin[i])
174 0 : if (pGridWin[i]->IsVisible())
175 : {
176 0 : pGridWin[i]->ShowCursor();
177 :
178 : // #114409#
179 0 : pGridWin[i]->CursorChanged();
180 : }
181 0 : }
182 :
183 0 : void ScTabView::ShowCursor()
184 : {
185 0 : pGridWin[aViewData.GetActivePart()]->ShowCursor();
186 :
187 : // #114409#
188 0 : pGridWin[aViewData.GetActivePart()]->CursorChanged();
189 0 : }
190 :
191 0 : void ScTabView::InvalidateAttribs()
192 : {
193 0 : SfxBindings& rBindings = aViewData.GetBindings();
194 :
195 0 : rBindings.Invalidate( SID_STYLE_APPLY );
196 0 : rBindings.Invalidate( SID_STYLE_FAMILY2 );
197 : // StarCalc kennt nur Absatz- bzw. Zellformat-Vorlagen
198 :
199 0 : rBindings.Invalidate( SID_ATTR_CHAR_FONT );
200 0 : rBindings.Invalidate( SID_ATTR_CHAR_FONTHEIGHT );
201 0 : rBindings.Invalidate( SID_ATTR_CHAR_COLOR );
202 :
203 0 : rBindings.Invalidate( SID_ATTR_CHAR_WEIGHT );
204 0 : rBindings.Invalidate( SID_ATTR_CHAR_POSTURE );
205 0 : rBindings.Invalidate( SID_ATTR_CHAR_UNDERLINE );
206 0 : rBindings.Invalidate( SID_ULINE_VAL_NONE );
207 0 : rBindings.Invalidate( SID_ULINE_VAL_SINGLE );
208 0 : rBindings.Invalidate( SID_ULINE_VAL_DOUBLE );
209 0 : rBindings.Invalidate( SID_ULINE_VAL_DOTTED );
210 :
211 0 : rBindings.Invalidate( SID_ATTR_CHAR_OVERLINE );
212 :
213 0 : rBindings.Invalidate( SID_ATTR_CHAR_KERNING );
214 0 : rBindings.Invalidate( SID_SET_SUPER_SCRIPT );
215 0 : rBindings.Invalidate( SID_SET_SUB_SCRIPT );
216 0 : rBindings.Invalidate( SID_ATTR_CHAR_STRIKEOUT );
217 0 : rBindings.Invalidate( SID_ATTR_CHAR_SHADOWED );
218 :
219 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_LEFT );
220 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_RIGHT );
221 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_BLOCK );
222 0 : rBindings.Invalidate( SID_ATTR_PARA_ADJUST_CENTER);
223 0 : rBindings.Invalidate( SID_NUMBER_TYPE_FORMAT);
224 :
225 0 : rBindings.Invalidate( SID_ALIGNLEFT );
226 0 : rBindings.Invalidate( SID_ALIGNRIGHT );
227 0 : rBindings.Invalidate( SID_ALIGNBLOCK );
228 0 : rBindings.Invalidate( SID_ALIGNCENTERHOR );
229 :
230 0 : rBindings.Invalidate( SID_ALIGNTOP );
231 0 : rBindings.Invalidate( SID_ALIGNBOTTOM );
232 0 : rBindings.Invalidate( SID_ALIGNCENTERVER );
233 :
234 : // stuff for sidebar panels
235 : {
236 0 : rBindings.Invalidate( SID_H_ALIGNCELL );
237 0 : rBindings.Invalidate( SID_V_ALIGNCELL );
238 0 : rBindings.Invalidate( SID_ATTR_ALIGN_INDENT );
239 0 : rBindings.Invalidate( SID_FRAME_LINECOLOR );
240 0 : rBindings.Invalidate( SID_FRAME_LINESTYLE );
241 0 : rBindings.Invalidate( SID_ATTR_BORDER_OUTER );
242 0 : rBindings.Invalidate( SID_ATTR_BORDER_INNER );
243 0 : rBindings.Invalidate( SID_ATTR_BORDER_DIAG_TLBR );
244 0 : rBindings.Invalidate( SID_ATTR_BORDER_DIAG_BLTR );
245 0 : rBindings.Invalidate( SID_NUMBER_TYPE_FORMAT );
246 : }
247 :
248 0 : rBindings.Invalidate( SID_BACKGROUND_COLOR );
249 :
250 0 : rBindings.Invalidate( SID_ATTR_ALIGN_LINEBREAK );
251 0 : rBindings.Invalidate( SID_NUMBER_FORMAT );
252 :
253 0 : rBindings.Invalidate( SID_TEXTDIRECTION_LEFT_TO_RIGHT );
254 0 : rBindings.Invalidate( SID_TEXTDIRECTION_TOP_TO_BOTTOM );
255 0 : rBindings.Invalidate( SID_ATTR_PARA_LEFT_TO_RIGHT );
256 0 : rBindings.Invalidate( SID_ATTR_PARA_RIGHT_TO_LEFT );
257 :
258 : // pseudo slots for Format menu
259 0 : rBindings.Invalidate( SID_ALIGN_ANY_HDEFAULT );
260 0 : rBindings.Invalidate( SID_ALIGN_ANY_LEFT );
261 0 : rBindings.Invalidate( SID_ALIGN_ANY_HCENTER );
262 0 : rBindings.Invalidate( SID_ALIGN_ANY_RIGHT );
263 0 : rBindings.Invalidate( SID_ALIGN_ANY_JUSTIFIED );
264 0 : rBindings.Invalidate( SID_ALIGN_ANY_VDEFAULT );
265 0 : rBindings.Invalidate( SID_ALIGN_ANY_TOP );
266 0 : rBindings.Invalidate( SID_ALIGN_ANY_VCENTER );
267 0 : rBindings.Invalidate( SID_ALIGN_ANY_BOTTOM );
268 :
269 0 : rBindings.Invalidate( SID_NUMBER_CURRENCY );
270 0 : rBindings.Invalidate( SID_NUMBER_SCIENTIFIC );
271 0 : rBindings.Invalidate( SID_NUMBER_DATE );
272 0 : rBindings.Invalidate( SID_NUMBER_CURRENCY );
273 0 : rBindings.Invalidate( SID_NUMBER_PERCENT );
274 0 : rBindings.Invalidate( SID_NUMBER_TIME );
275 0 : }
276 :
277 : // SetCursor - Cursor setzen, zeichnen, InputWin updaten
278 : // oder Referenz verschicken
279 : // ohne Optimierung wegen BugId 29307
280 :
281 0 : void ScTabView::SetCursor( SCCOL nPosX, SCROW nPosY, bool bNew )
282 : {
283 0 : SCCOL nOldX = aViewData.GetCurX();
284 0 : SCROW nOldY = aViewData.GetCurY();
285 :
286 : // DeactivateIP nur noch bei MarkListHasChanged
287 :
288 0 : if ( nPosX != nOldX || nPosY != nOldY || bNew )
289 : {
290 0 : ScTabViewShell* pViewShell = aViewData.GetViewShell();
291 0 : bool bRefMode = ( pViewShell ? pViewShell->IsRefInputMode() : false );
292 0 : if ( aViewData.HasEditView( aViewData.GetActivePart() ) && !bRefMode ) // 23259 oder so
293 : {
294 0 : UpdateInputLine();
295 : }
296 :
297 0 : HideAllCursors();
298 :
299 0 : aViewData.SetCurX( nPosX );
300 0 : aViewData.SetCurY( nPosY );
301 :
302 0 : ShowAllCursors();
303 :
304 0 : CursorPosChanged();
305 : }
306 0 : }
307 :
308 0 : void ScTabView::CheckSelectionTransfer()
309 : {
310 0 : if ( aViewData.IsActive() ) // only for active view
311 : {
312 0 : ScModule* pScMod = SC_MOD();
313 0 : ScSelectionTransferObj* pOld = pScMod->GetSelectionTransfer();
314 0 : if ( pOld && pOld->GetView() == this && pOld->StillValid() )
315 : {
316 : // selection not changed - nothing to do
317 : }
318 : else
319 : {
320 0 : ScSelectionTransferObj* pNew = ScSelectionTransferObj::CreateFromView( this );
321 0 : if ( pNew )
322 : {
323 : // create new selection
324 :
325 0 : if (pOld)
326 0 : pOld->ForgetView();
327 :
328 0 : uno::Reference<datatransfer::XTransferable> xRef( pNew );
329 0 : pScMod->SetSelectionTransfer( pNew );
330 0 : pNew->CopyToSelection( GetActiveWin() ); // may delete pOld
331 : }
332 0 : else if ( pOld && pOld->GetView() == this )
333 : {
334 : // remove own selection
335 :
336 0 : pOld->ForgetView();
337 0 : pScMod->SetSelectionTransfer( NULL );
338 0 : TransferableHelper::ClearSelection( GetActiveWin() ); // may delete pOld
339 : }
340 : // else: selection from outside: leave unchanged
341 : }
342 : }
343 0 : }
344 :
345 : // Eingabezeile / Menues updaten
346 : // CursorPosChanged ruft SelectionChanged
347 : // SelectionChanged ruft CellContentChanged
348 :
349 0 : void ScTabView::CellContentChanged()
350 : {
351 0 : SfxBindings& rBindings = aViewData.GetBindings();
352 :
353 0 : rBindings.Invalidate( SID_ATTR_SIZE ); // -> Fehlermeldungen anzeigen
354 0 : rBindings.Invalidate( SID_THESAURUS );
355 0 : rBindings.Invalidate( SID_HYPERLINK_GETLINK );
356 0 : rBindings.Invalidate( SID_ROWCOL_SELCOUNT );
357 :
358 0 : InvalidateAttribs(); // Attribut-Updates
359 :
360 0 : aViewData.GetViewShell()->UpdateInputHandler();
361 0 : }
362 :
363 0 : void ScTabView::SelectionChanged()
364 : {
365 0 : SfxViewFrame* pViewFrame = aViewData.GetViewShell()->GetViewFrame();
366 0 : if (pViewFrame)
367 : {
368 0 : uno::Reference<frame::XController> xController = pViewFrame->GetFrame().GetController();
369 0 : if (xController.is())
370 : {
371 0 : ScTabViewObj* pImp = ScTabViewObj::getImplementation( xController );
372 0 : if (pImp)
373 0 : pImp->SelectionChanged();
374 0 : }
375 : }
376 :
377 0 : UpdateAutoFillMark(); // also calls CheckSelectionTransfer
378 :
379 0 : SfxBindings& rBindings = aViewData.GetBindings();
380 :
381 0 : rBindings.Invalidate( SID_CURRENTCELL ); // -> Navigator
382 0 : rBindings.Invalidate( SID_AUTO_FILTER ); // -> Menue
383 0 : rBindings.Invalidate( FID_NOTE_VISIBLE );
384 0 : rBindings.Invalidate( FID_SHOW_NOTE );
385 0 : rBindings.Invalidate( FID_HIDE_NOTE );
386 0 : rBindings.Invalidate( SID_DELETE_NOTE );
387 0 : rBindings.Invalidate( SID_ROWCOL_SELCOUNT );
388 :
389 : // Funktionen, die evtl disabled werden muessen
390 :
391 0 : rBindings.Invalidate( FID_INS_ROWBRK );
392 0 : rBindings.Invalidate( FID_INS_COLBRK );
393 0 : rBindings.Invalidate( FID_DEL_ROWBRK );
394 0 : rBindings.Invalidate( FID_DEL_COLBRK );
395 0 : rBindings.Invalidate( FID_MERGE_ON );
396 0 : rBindings.Invalidate( FID_MERGE_OFF );
397 0 : rBindings.Invalidate( FID_MERGE_TOGGLE );
398 0 : rBindings.Invalidate( SID_AUTOFILTER_HIDE );
399 0 : rBindings.Invalidate( SID_UNFILTER );
400 0 : rBindings.Invalidate( SID_REIMPORT_DATA );
401 0 : rBindings.Invalidate( SID_REFRESH_DBAREA );
402 0 : rBindings.Invalidate( SID_OUTLINE_SHOW );
403 0 : rBindings.Invalidate( SID_OUTLINE_HIDE );
404 0 : rBindings.Invalidate( SID_OUTLINE_REMOVE );
405 0 : rBindings.Invalidate( FID_FILL_TO_BOTTOM );
406 0 : rBindings.Invalidate( FID_FILL_TO_RIGHT );
407 0 : rBindings.Invalidate( FID_FILL_TO_TOP );
408 0 : rBindings.Invalidate( FID_FILL_TO_LEFT );
409 0 : rBindings.Invalidate( FID_FILL_SERIES );
410 0 : rBindings.Invalidate( SID_SCENARIOS );
411 0 : rBindings.Invalidate( SID_AUTOFORMAT );
412 0 : rBindings.Invalidate( SID_OPENDLG_TABOP );
413 0 : rBindings.Invalidate( SID_DATA_SELECT );
414 :
415 0 : rBindings.Invalidate( SID_CUT );
416 0 : rBindings.Invalidate( SID_COPY );
417 0 : rBindings.Invalidate( SID_PASTE );
418 0 : rBindings.Invalidate( SID_PASTE_SPECIAL );
419 :
420 0 : rBindings.Invalidate( FID_INS_ROW );
421 0 : rBindings.Invalidate( FID_INS_COLUMN );
422 0 : rBindings.Invalidate( FID_INS_CELL );
423 0 : rBindings.Invalidate( FID_INS_CELLSDOWN );
424 0 : rBindings.Invalidate( FID_INS_CELLSRIGHT );
425 :
426 0 : rBindings.Invalidate( FID_CHG_COMMENT );
427 :
428 : // nur wegen Zellschutz:
429 :
430 0 : rBindings.Invalidate( SID_CELL_FORMAT_RESET );
431 0 : rBindings.Invalidate( SID_DELETE );
432 0 : rBindings.Invalidate( SID_DELETE_CONTENTS );
433 0 : rBindings.Invalidate( FID_DELETE_CELL );
434 0 : rBindings.Invalidate( FID_CELL_FORMAT );
435 0 : rBindings.Invalidate( SID_ENABLE_HYPHENATION );
436 0 : rBindings.Invalidate( SID_INSERT_POSTIT );
437 0 : rBindings.Invalidate( SID_CHARMAP );
438 0 : rBindings.Invalidate( SID_OPENDLG_FUNCTION );
439 0 : rBindings.Invalidate( FID_VALIDATION );
440 0 : rBindings.Invalidate( SID_EXTERNAL_SOURCE );
441 0 : rBindings.Invalidate( SID_TEXT_TO_COLUMNS );
442 0 : rBindings.Invalidate( SID_SORT_ASCENDING );
443 0 : rBindings.Invalidate( SID_SORT_DESCENDING );
444 :
445 0 : if (aViewData.GetViewShell()->HasAccessibilityObjects())
446 0 : aViewData.GetViewShell()->BroadcastAccessibility(SfxSimpleHint(SC_HINT_ACC_CURSORCHANGED));
447 :
448 0 : CellContentChanged();
449 0 : }
450 :
451 0 : void ScTabView::CursorPosChanged()
452 : {
453 0 : bool bRefMode = SC_MOD()->IsFormulaMode();
454 0 : if ( !bRefMode ) // Abfrage, damit RefMode bei Tabellenwechsel funktioniert
455 0 : aViewData.GetDocShell()->Broadcast( SfxSimpleHint( FID_KILLEDITVIEW ) );
456 :
457 : // Broadcast, damit andere Views des Dokuments auch umschalten
458 :
459 0 : ScDocument* pDoc = aViewData.GetDocument();
460 : bool bDP = NULL != pDoc->GetDPAtCursor(
461 0 : aViewData.GetCurX(), aViewData.GetCurY(), aViewData.GetTabNo() );
462 0 : aViewData.GetViewShell()->SetPivotShell(bDP);
463 :
464 : // UpdateInputHandler jetzt in CellContentChanged
465 :
466 0 : SelectionChanged();
467 :
468 0 : aViewData.SetTabStartCol( SC_TABSTART_NONE );
469 0 : }
470 :
471 : namespace {
472 :
473 0 : Point calcHintWindowPosition(
474 : const Point& rCellPos, const Size& rCellSize, const Size& rFrameWndSize, const Size& rHintWndSize)
475 : {
476 0 : const long nMargin = 20;
477 :
478 0 : long nMLeft = rCellPos.X();
479 0 : long nMRight = rFrameWndSize.Width() - rCellPos.X() - rCellSize.Width();
480 0 : long nMTop = rCellPos.Y();
481 0 : long nMBottom = rFrameWndSize.Height() - rCellPos.Y() - rCellSize.Height();
482 :
483 : // First, see if we can fit the entire hint window in the visible region.
484 :
485 0 : if (nMRight - nMargin >= rHintWndSize.Width())
486 : {
487 : // Right margin is wide enough.
488 0 : if (rFrameWndSize.Height() >= rHintWndSize.Height())
489 : {
490 : // The frame has enough height. Take it.
491 0 : Point aPos = rCellPos;
492 0 : aPos.X() += rCellSize.Width() + nMargin;
493 0 : if (aPos.Y() + rHintWndSize.Height() > rFrameWndSize.Height())
494 : {
495 : // Push the hint window up a bit to make it fit.
496 0 : aPos.Y() = rFrameWndSize.Height() - rHintWndSize.Height();
497 : }
498 0 : return aPos;
499 : }
500 : }
501 :
502 0 : if (nMBottom - nMargin >= rHintWndSize.Height())
503 : {
504 : // Bottom margin is high enough.
505 0 : if (rFrameWndSize.Width() >= rHintWndSize.Width())
506 : {
507 : // The frame has enough width. Take it.
508 0 : Point aPos = rCellPos;
509 0 : aPos.Y() += rCellSize.Height() + nMargin;
510 0 : if (aPos.X() + rHintWndSize.Width() > rFrameWndSize.Width())
511 : {
512 : // Move the hint window to the left to make it fit.
513 0 : aPos.X() = rFrameWndSize.Width() - rHintWndSize.Width();
514 : }
515 0 : return aPos;
516 : }
517 : }
518 :
519 0 : if (nMLeft - nMargin >= rHintWndSize.Width())
520 : {
521 : // Left margin is wide enough.
522 0 : if (rFrameWndSize.Height() >= rHintWndSize.Height())
523 : {
524 : // The frame is high enough. Take it.
525 0 : Point aPos = rCellPos;
526 0 : aPos.X() -= rHintWndSize.Width() + nMargin;
527 0 : if (aPos.Y() + rHintWndSize.Height() > rFrameWndSize.Height())
528 : {
529 : // Push the hint window up a bit to make it fit.
530 0 : aPos.Y() = rFrameWndSize.Height() - rHintWndSize.Height();
531 : }
532 0 : return aPos;
533 : }
534 : }
535 :
536 0 : if (nMTop - nMargin >= rHintWndSize.Height())
537 : {
538 : // Top margin is high enough.
539 0 : if (rFrameWndSize.Width() >= rHintWndSize.Width())
540 : {
541 : // The frame is wide enough. Take it.
542 0 : Point aPos = rCellPos;
543 0 : aPos.Y() -= rHintWndSize.Height() + nMargin;
544 0 : if (aPos.X() + rHintWndSize.Width() > rFrameWndSize.Width())
545 : {
546 : // Move the hint window to the left to make it fit.
547 0 : aPos.X() = rFrameWndSize.Width() - rHintWndSize.Width();
548 : }
549 0 : return aPos;
550 : }
551 : }
552 :
553 : // The popup doesn't fit in any direction in its entirety. Do our best.
554 :
555 0 : if (nMRight - nMargin >= rHintWndSize.Width())
556 : {
557 : // Right margin is good enough.
558 0 : Point aPos = rCellPos;
559 0 : aPos.X() += nMargin + rCellSize.Width();
560 0 : aPos.Y() = 0;
561 0 : return aPos;
562 : }
563 :
564 0 : if (nMBottom - nMargin >= rHintWndSize.Height())
565 : {
566 : // Bottom margin is good enough.
567 0 : Point aPos = rCellPos;
568 0 : aPos.Y() += nMargin + rCellSize.Height();
569 0 : aPos.X() = 0;
570 0 : return aPos;
571 : }
572 :
573 0 : if (nMLeft - nMargin >= rHintWndSize.Width())
574 : {
575 : // Left margin is good enough.
576 0 : Point aPos = rCellPos;
577 0 : aPos.X() -= rHintWndSize.Width() + nMargin;
578 0 : aPos.Y() = 0;
579 0 : return aPos;
580 : }
581 :
582 0 : if (nMTop - nMargin >= rHintWndSize.Height())
583 : {
584 : // Top margin is good enough.
585 0 : Point aPos = rCellPos;
586 0 : aPos.Y() -= rHintWndSize.Height() + nMargin;
587 0 : aPos.X() = 0;
588 0 : return aPos;
589 : }
590 :
591 : // None of the above. Hopeless. At least try not to cover the current
592 : // cell.
593 0 : Point aPos = rCellPos;
594 0 : aPos.X() += rCellSize.Width();
595 0 : return aPos;
596 : }
597 :
598 : }
599 :
600 0 : void ScTabView::TestHintWindow()
601 : {
602 : // show input help window and list drop-down button for validity
603 :
604 0 : bool bListValButton = false;
605 0 : ScAddress aListValPos;
606 :
607 0 : ScDocument* pDoc = aViewData.GetDocument();
608 : const SfxUInt32Item* pItem = (const SfxUInt32Item*)
609 0 : pDoc->GetAttr( aViewData.GetCurX(),
610 : aViewData.GetCurY(),
611 0 : aViewData.GetTabNo(),
612 0 : ATTR_VALIDDATA );
613 0 : if ( pItem->GetValue() )
614 : {
615 0 : const ScValidationData* pData = pDoc->GetValidationEntry( pItem->GetValue() );
616 : OSL_ENSURE(pData,"ValidationData nicht gefunden");
617 0 : OUString aTitle, aMessage;
618 0 : if ( pData && pData->GetInput( aTitle, aMessage ) && !aMessage.isEmpty() )
619 : {
620 : //! Abfrage, ob an gleicher Stelle !!!!
621 :
622 0 : mpInputHintWindow.reset();
623 :
624 0 : ScSplitPos eWhich = aViewData.GetActivePart();
625 0 : ScGridWindow* pWin = pGridWin[eWhich];
626 0 : SCCOL nCol = aViewData.GetCurX();
627 0 : SCROW nRow = aViewData.GetCurY();
628 0 : Point aPos = aViewData.GetScrPos( nCol, nRow, eWhich );
629 0 : Size aWinSize = pWin->GetOutputSizePixel();
630 : // Cursor sichtbar?
631 0 : if ( nCol >= aViewData.GetPosX(WhichH(eWhich)) &&
632 0 : nRow >= aViewData.GetPosY(WhichV(eWhich)) &&
633 0 : aPos.X() < aWinSize.Width() && aPos.Y() < aWinSize.Height() )
634 : {
635 : // HintWindow anlegen, bestimmt seine Groesse selbst
636 0 : mpInputHintWindow.reset(new ScHintWindow(pWin, aTitle, aMessage));
637 0 : Size aHintWndSize = mpInputHintWindow->GetSizePixel();
638 0 : long nCellSizeX = 0;
639 0 : long nCellSizeY = 0;
640 0 : aViewData.GetMergeSizePixel(nCol, nRow, nCellSizeX, nCellSizeY);
641 :
642 : Point aHintPos = calcHintWindowPosition(
643 0 : aPos, Size(nCellSizeX,nCellSizeY), aWinSize, aHintWndSize);
644 :
645 0 : mpInputHintWindow->SetPosPixel( aHintPos );
646 0 : mpInputHintWindow->ToTop();
647 0 : mpInputHintWindow->Show();
648 : }
649 : }
650 : else
651 0 : mpInputHintWindow.reset();
652 :
653 : // list drop-down button
654 0 : if ( pData && pData->HasSelectionList() )
655 : {
656 0 : aListValPos.Set( aViewData.GetCurX(), aViewData.GetCurY(), aViewData.GetTabNo() );
657 0 : bListValButton = true;
658 0 : }
659 : }
660 : else
661 0 : mpInputHintWindow.reset();
662 :
663 0 : for ( sal_uInt16 i=0; i<4; i++ )
664 0 : if ( pGridWin[i] && pGridWin[i]->IsVisible() )
665 0 : pGridWin[i]->UpdateListValPos( bListValButton, aListValPos );
666 0 : }
667 :
668 0 : bool ScTabView::HasHintWindow() const
669 : {
670 0 : return mpInputHintWindow.get() != NULL;
671 : }
672 :
673 0 : void ScTabView::RemoveHintWindow()
674 : {
675 0 : mpInputHintWindow.reset();
676 0 : }
677 :
678 :
679 : // find window that should not be over the cursor
680 0 : static Window* lcl_GetCareWin(SfxViewFrame* pViewFrm)
681 : {
682 : //! auch Spelling ??? (dann beim Aufruf Membervariable setzen)
683 :
684 : // Suchen & Ersetzen
685 0 : if ( pViewFrm->HasChildWindow(SID_SEARCH_DLG) )
686 : {
687 0 : SfxChildWindow* pChild = pViewFrm->GetChildWindow(SID_SEARCH_DLG);
688 0 : if (pChild)
689 : {
690 0 : Window* pWin = pChild->GetWindow();
691 0 : if (pWin && pWin->IsVisible())
692 0 : return pWin;
693 : }
694 : }
695 :
696 : // Aenderungen uebernehmen
697 0 : if ( pViewFrm->HasChildWindow(FID_CHG_ACCEPT) )
698 : {
699 0 : SfxChildWindow* pChild = pViewFrm->GetChildWindow(FID_CHG_ACCEPT);
700 0 : if (pChild)
701 : {
702 0 : Window* pWin = pChild->GetWindow();
703 0 : if (pWin && pWin->IsVisible())
704 0 : return pWin;
705 : }
706 : }
707 :
708 0 : return NULL;
709 : }
710 :
711 :
712 : // Bildschirm an Cursorposition anpassen
713 :
714 :
715 0 : void ScTabView::AlignToCursor( SCsCOL nCurX, SCsROW nCurY, ScFollowMode eMode,
716 : const ScSplitPos* pWhich )
717 : {
718 :
719 : // aktiven Teil umschalten jetzt hier
720 :
721 :
722 0 : ScSplitPos eActive = aViewData.GetActivePart();
723 0 : ScHSplitPos eActiveX = WhichH(eActive);
724 0 : ScVSplitPos eActiveY = WhichV(eActive);
725 0 : bool bHFix = (aViewData.GetHSplitMode() == SC_SPLIT_FIX);
726 0 : bool bVFix = (aViewData.GetVSplitMode() == SC_SPLIT_FIX);
727 0 : if (bHFix)
728 0 : if (eActiveX == SC_SPLIT_LEFT && nCurX >= (SCsCOL)aViewData.GetFixPosX())
729 : {
730 0 : ActivatePart( (eActiveY==SC_SPLIT_TOP) ? SC_SPLIT_TOPRIGHT : SC_SPLIT_BOTTOMRIGHT );
731 0 : eActiveX = SC_SPLIT_RIGHT;
732 : }
733 0 : if (bVFix)
734 0 : if (eActiveY == SC_SPLIT_TOP && nCurY >= (SCsROW)aViewData.GetFixPosY())
735 : {
736 0 : ActivatePart( (eActiveX==SC_SPLIT_LEFT) ? SC_SPLIT_BOTTOMLEFT : SC_SPLIT_BOTTOMRIGHT );
737 0 : eActiveY = SC_SPLIT_BOTTOM;
738 : }
739 :
740 :
741 : // eigentliches Align
742 :
743 :
744 0 : if ( eMode != SC_FOLLOW_NONE )
745 : {
746 : ScSplitPos eAlign;
747 0 : if (pWhich)
748 0 : eAlign = *pWhich;
749 : else
750 0 : eAlign = aViewData.GetActivePart();
751 0 : ScHSplitPos eAlignX = WhichH(eAlign);
752 0 : ScVSplitPos eAlignY = WhichV(eAlign);
753 :
754 0 : SCsCOL nDeltaX = (SCsCOL) aViewData.GetPosX(eAlignX);
755 0 : SCsROW nDeltaY = (SCsROW) aViewData.GetPosY(eAlignY);
756 0 : SCsCOL nSizeX = (SCsCOL) aViewData.VisibleCellsX(eAlignX);
757 0 : SCsROW nSizeY = (SCsROW) aViewData.VisibleCellsY(eAlignY);
758 :
759 : long nCellSizeX;
760 : long nCellSizeY;
761 0 : if ( nCurX >= 0 && nCurY >= 0 )
762 0 : aViewData.GetMergeSizePixel( (SCCOL)nCurX, (SCROW)nCurY, nCellSizeX, nCellSizeY );
763 : else
764 0 : nCellSizeX = nCellSizeY = 0;
765 0 : Size aScrSize = aViewData.GetScrSize();
766 0 : long nSpaceX = ( aScrSize.Width() - nCellSizeX ) / 2;
767 0 : long nSpaceY = ( aScrSize.Height() - nCellSizeY ) / 2;
768 : // nSpaceY: desired start position of cell for FOLLOW_JUMP, modified if dialog interferes
769 :
770 0 : bool bForceNew = false; // force new calculation of JUMP position (vertical only)
771 :
772 : // VisibleCellsY == CellsAtY( GetPosY( eWhichY ), 1, eWhichY )
773 :
774 :
775 : // falls z.B. Suchen-Dialog offen ist, Cursor nicht hinter den Dialog stellen
776 : // wenn moeglich, die Zeile mit dem Cursor oberhalb oder unterhalb des Dialogs
777 :
778 : //! nicht, wenn schon komplett sichtbar
779 :
780 0 : if ( eMode == SC_FOLLOW_JUMP )
781 : {
782 0 : Window* pCare = lcl_GetCareWin( aViewData.GetViewShell()->GetViewFrame() );
783 0 : if (pCare)
784 : {
785 0 : bool bLimit = false;
786 0 : Rectangle aDlgPixel;
787 0 : Size aWinSize;
788 0 : Window* pWin = GetActiveWin();
789 0 : if (pWin)
790 : {
791 0 : aDlgPixel = pCare->GetWindowExtentsRelative( pWin );
792 0 : aWinSize = pWin->GetOutputSizePixel();
793 : // ueberdeckt der Dialog das GridWin?
794 0 : if ( aDlgPixel.Right() >= 0 && aDlgPixel.Left() < aWinSize.Width() )
795 : {
796 0 : if ( nCurX < nDeltaX || nCurX >= nDeltaX+nSizeX ||
797 0 : nCurY < nDeltaY || nCurY >= nDeltaY+nSizeY )
798 0 : bLimit = true; // es wird sowieso gescrollt
799 : else
800 : {
801 : // Cursor ist auf dem Bildschirm
802 0 : Point aStart = aViewData.GetScrPos( nCurX, nCurY, eAlign );
803 : long nCSX, nCSY;
804 0 : aViewData.GetMergeSizePixel( nCurX, nCurY, nCSX, nCSY );
805 0 : Rectangle aCursor( aStart, Size( nCSX, nCSY ) );
806 0 : if ( aCursor.IsOver( aDlgPixel ) )
807 0 : bLimit = true; // Zelle vom Dialog ueberdeckt
808 : }
809 : }
810 : }
811 :
812 0 : if (bLimit)
813 : {
814 0 : bool bBottom = false;
815 0 : long nTopSpace = aDlgPixel.Top();
816 0 : long nBotSpace = aWinSize.Height() - aDlgPixel.Bottom();
817 0 : if ( nBotSpace > 0 && nBotSpace > nTopSpace )
818 : {
819 0 : long nDlgBot = aDlgPixel.Bottom();
820 : SCsCOL nWPosX;
821 : SCsROW nWPosY;
822 0 : aViewData.GetPosFromPixel( 0,nDlgBot, eAlign, nWPosX, nWPosY );
823 0 : ++nWPosY; // unter der letzten betroffenen Zelle
824 :
825 0 : SCsROW nDiff = nWPosY - nDeltaY;
826 0 : if ( nCurY >= nDiff ) // Pos. kann nicht negativ werden
827 : {
828 0 : nSpaceY = nDlgBot + ( nBotSpace - nCellSizeY ) / 2;
829 0 : bBottom = true;
830 0 : bForceNew = true;
831 : }
832 : }
833 0 : if ( !bBottom && nTopSpace > 0 )
834 : {
835 0 : nSpaceY = ( nTopSpace - nCellSizeY ) / 2;
836 0 : bForceNew = true;
837 : }
838 : }
839 : }
840 : }
841 :
842 :
843 0 : SCsCOL nNewDeltaX = nDeltaX;
844 0 : SCsROW nNewDeltaY = nDeltaY;
845 0 : bool bDoLine = false;
846 :
847 0 : switch (eMode)
848 : {
849 : case SC_FOLLOW_JUMP:
850 0 : if ( nCurX < nDeltaX || nCurX >= nDeltaX+nSizeX )
851 : {
852 0 : nNewDeltaX = nCurX - static_cast<SCsCOL>(aViewData.CellsAtX( nCurX, -1, eAlignX, static_cast<sal_uInt16>(nSpaceX) ));
853 0 : if (nNewDeltaX < 0) nNewDeltaX = 0;
854 0 : nSizeX = (SCsCOL) aViewData.CellsAtX( nNewDeltaX, 1, eAlignX );
855 : }
856 0 : if ( nCurY < nDeltaY || nCurY >= nDeltaY+nSizeY || bForceNew )
857 : {
858 0 : nNewDeltaY = nCurY - static_cast<SCsROW>(aViewData.CellsAtY( nCurY, -1, eAlignY, static_cast<sal_uInt16>(nSpaceY) ));
859 0 : if (nNewDeltaY < 0) nNewDeltaY = 0;
860 0 : nSizeY = (SCsROW) aViewData.CellsAtY( nNewDeltaY, 1, eAlignY );
861 : }
862 0 : bDoLine = true;
863 0 : break;
864 :
865 : case SC_FOLLOW_LINE:
866 0 : bDoLine = true;
867 0 : break;
868 :
869 : case SC_FOLLOW_FIX:
870 0 : if ( nCurX < nDeltaX || nCurX >= nDeltaX+nSizeX )
871 : {
872 0 : nNewDeltaX = nDeltaX + nCurX - aViewData.GetCurX();
873 0 : if (nNewDeltaX < 0) nNewDeltaX = 0;
874 0 : nSizeX = (SCsCOL) aViewData.CellsAtX( nNewDeltaX, 1, eAlignX );
875 : }
876 0 : if ( nCurY < nDeltaY || nCurY >= nDeltaY+nSizeY )
877 : {
878 0 : nNewDeltaY = nDeltaY + nCurY - aViewData.GetCurY();
879 0 : if (nNewDeltaY < 0) nNewDeltaY = 0;
880 0 : nSizeY = (SCsROW) aViewData.CellsAtY( nNewDeltaY, 1, eAlignY );
881 : }
882 :
883 : // like old version of SC_FOLLOW_JUMP:
884 :
885 0 : if ( nCurX < nNewDeltaX || nCurX >= nNewDeltaX+nSizeX )
886 : {
887 0 : nNewDeltaX = nCurX - (nSizeX / 2);
888 0 : if (nNewDeltaX < 0) nNewDeltaX = 0;
889 0 : nSizeX = (SCsCOL) aViewData.CellsAtX( nNewDeltaX, 1, eAlignX );
890 : }
891 0 : if ( nCurY < nNewDeltaY || nCurY >= nNewDeltaY+nSizeY )
892 : {
893 0 : nNewDeltaY = nCurY - (nSizeY / 2);
894 0 : if (nNewDeltaY < 0) nNewDeltaY = 0;
895 0 : nSizeY = (SCsROW) aViewData.CellsAtY( nNewDeltaY, 1, eAlignY );
896 : }
897 :
898 0 : bDoLine = true;
899 0 : break;
900 :
901 : case SC_FOLLOW_NONE:
902 0 : break;
903 : default:
904 : OSL_FAIL("Falscher Cursormodus");
905 0 : break;
906 : }
907 :
908 0 : if (bDoLine)
909 : {
910 0 : while ( nCurX >= nNewDeltaX+nSizeX )
911 : {
912 0 : nNewDeltaX = nCurX-nSizeX+1;
913 0 : ScDocument* pDoc = aViewData.GetDocument();
914 0 : SCTAB nTab = aViewData.GetTabNo();
915 0 : while ( nNewDeltaX < MAXCOL && !pDoc->GetColWidth( nNewDeltaX, nTab ) )
916 0 : ++nNewDeltaX;
917 0 : nSizeX = (SCsCOL) aViewData.CellsAtX( nNewDeltaX, 1, eAlignX );
918 : }
919 0 : while ( nCurY >= nNewDeltaY+nSizeY )
920 : {
921 0 : nNewDeltaY = nCurY-nSizeY+1;
922 0 : ScDocument* pDoc = aViewData.GetDocument();
923 0 : SCTAB nTab = aViewData.GetTabNo();
924 0 : while ( nNewDeltaY < MAXROW && !pDoc->GetRowHeight( nNewDeltaY, nTab ) )
925 0 : ++nNewDeltaY;
926 0 : nSizeY = (SCsROW) aViewData.CellsAtY( nNewDeltaY, 1, eAlignY );
927 : }
928 0 : if ( nCurX < nNewDeltaX ) nNewDeltaX = nCurX;
929 0 : if ( nCurY < nNewDeltaY ) nNewDeltaY = nCurY;
930 : }
931 :
932 0 : if ( nNewDeltaX != nDeltaX )
933 0 : nSizeX = (SCsCOL) aViewData.CellsAtX( nNewDeltaX, 1, eAlignX );
934 0 : if (nNewDeltaX+nSizeX-1 > MAXCOL) nNewDeltaX = MAXCOL-nSizeX+1;
935 0 : if (nNewDeltaX < 0) nNewDeltaX = 0;
936 :
937 0 : if ( nNewDeltaY != nDeltaY )
938 0 : nSizeY = (SCsROW) aViewData.CellsAtY( nNewDeltaY, 1, eAlignY );
939 0 : if (nNewDeltaY+nSizeY-1 > MAXROW) nNewDeltaY = MAXROW-nSizeY+1;
940 0 : if (nNewDeltaY < 0) nNewDeltaY = 0;
941 :
942 0 : if ( nNewDeltaX != nDeltaX ) ScrollX( nNewDeltaX - nDeltaX, eAlignX );
943 0 : if ( nNewDeltaY != nDeltaY ) ScrollY( nNewDeltaY - nDeltaY, eAlignY );
944 : }
945 :
946 :
947 : // nochmal aktiven Teil umschalten
948 :
949 :
950 0 : if (bHFix)
951 0 : if (eActiveX == SC_SPLIT_RIGHT && nCurX < (SCsCOL)aViewData.GetFixPosX())
952 : {
953 0 : ActivatePart( (eActiveY==SC_SPLIT_TOP) ? SC_SPLIT_TOPLEFT : SC_SPLIT_BOTTOMLEFT );
954 0 : eActiveX = SC_SPLIT_LEFT;
955 : }
956 0 : if (bVFix)
957 0 : if (eActiveY == SC_SPLIT_BOTTOM && nCurY < (SCsROW)aViewData.GetFixPosY())
958 : {
959 0 : ActivatePart( (eActiveX==SC_SPLIT_LEFT) ? SC_SPLIT_TOPLEFT : SC_SPLIT_TOPRIGHT );
960 0 : eActiveY = SC_SPLIT_TOP;
961 : }
962 0 : }
963 :
964 0 : bool ScTabView::SelMouseButtonDown( const MouseEvent& rMEvt )
965 : {
966 0 : bool bRet = false;
967 :
968 : // #i3875# *Hack*
969 0 : bool bMod1Locked = aViewData.GetViewShell()->GetLockedModifiers() & KEY_MOD1 ? true : false;
970 0 : aViewData.SetSelCtrlMouseClick( rMEvt.IsMod1() || bMod1Locked );
971 :
972 0 : if ( pSelEngine )
973 : {
974 0 : bMoveIsShift = rMEvt.IsShift();
975 0 : bRet = pSelEngine->SelMouseButtonDown( rMEvt );
976 0 : bMoveIsShift = false;
977 : }
978 :
979 0 : aViewData.SetSelCtrlMouseClick( false ); // #i3875# *Hack*
980 :
981 0 : return bRet;
982 : }
983 :
984 :
985 : // MoveCursor - mit Anpassung des Bildausschnitts
986 :
987 :
988 0 : void ScTabView::MoveCursorAbs( SCsCOL nCurX, SCsROW nCurY, ScFollowMode eMode,
989 : bool bShift, bool bControl, bool bKeepOld, bool bKeepSel )
990 : {
991 0 : if (!bKeepOld)
992 0 : aViewData.ResetOldCursor();
993 :
994 : // #i123629#
995 0 : if( aViewData.GetViewShell()->GetForceFocusOnCurCell() )
996 0 : aViewData.GetViewShell()->SetForceFocusOnCurCell( !ValidColRow(nCurX, nCurY) );
997 :
998 0 : if (nCurX < 0) nCurX = 0;
999 0 : if (nCurY < 0) nCurY = 0;
1000 0 : if (nCurX > MAXCOL) nCurX = MAXCOL;
1001 0 : if (nCurY > MAXROW) nCurY = MAXROW;
1002 :
1003 0 : HideAllCursors();
1004 :
1005 : // aktiven Teil umschalten jetzt in AlignToCursor
1006 :
1007 0 : AlignToCursor( nCurX, nCurY, eMode );
1008 : //! auf OS/2: SC_FOLLOW_JUMP statt SC_FOLLOW_LINE, um Nachlaufen zu verhindern ???
1009 :
1010 0 : if (bKeepSel)
1011 : {
1012 0 : SetCursor( nCurX, nCurY ); // Markierung stehenlassen
1013 :
1014 : // If the cursor is in existing selection, it's a cursor movement by
1015 : // ENTER or TAB. If not, then it's a new selection during ADD
1016 : // selection mode.
1017 :
1018 0 : const ScMarkData& rMark = aViewData.GetMarkData();
1019 0 : ScRangeList aSelList;
1020 0 : rMark.FillRangeListWithMarks(&aSelList, false);
1021 0 : if (!aSelList.In(ScRange(nCurX, nCurY, aViewData.GetTabNo())))
1022 : // Cursor not in existing selection. Start a new selection.
1023 0 : DoneBlockMode(true);
1024 : }
1025 : else
1026 : {
1027 0 : if (!bShift)
1028 : {
1029 : // Remove all marked data on cursor movement unless the Shift is locked.
1030 0 : ScMarkData& rMark = aViewData.GetMarkData();
1031 0 : bool bMarked = rMark.IsMarked() || rMark.IsMultiMarked();
1032 0 : if (bMarked)
1033 : {
1034 0 : rMark.ResetMark();
1035 0 : DoneBlockMode();
1036 0 : InitOwnBlockMode();
1037 0 : MarkDataChanged();
1038 : }
1039 : }
1040 :
1041 0 : bool bSame = ( nCurX == aViewData.GetCurX() && nCurY == aViewData.GetCurY() );
1042 0 : bMoveIsShift = bShift;
1043 0 : pSelEngine->CursorPosChanging( bShift, bControl );
1044 0 : bMoveIsShift = false;
1045 0 : aFunctionSet.SetCursorAtCell( nCurX, nCurY, false );
1046 :
1047 : // Wenn der Cursor nicht bewegt wurde, muss das SelectionChanged fuer das
1048 : // Aufheben der Selektion hier einzeln passieren:
1049 0 : if (bSame)
1050 0 : SelectionChanged();
1051 : }
1052 :
1053 0 : ShowAllCursors();
1054 0 : TestHintWindow();
1055 0 : }
1056 :
1057 0 : void ScTabView::MoveCursorRel( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode,
1058 : bool bShift, bool bKeepSel )
1059 : {
1060 0 : ScDocument* pDoc = aViewData.GetDocument();
1061 0 : SCTAB nTab = aViewData.GetTabNo();
1062 :
1063 0 : bool bSkipProtected = false, bSkipUnprotected = false;
1064 0 : ScTableProtection* pProtect = pDoc->GetTabProtection(nTab);
1065 0 : if ( pProtect && pProtect->isProtected() )
1066 : {
1067 0 : bSkipProtected = !pProtect->isOptionEnabled(ScTableProtection::SELECT_LOCKED_CELLS);
1068 0 : bSkipUnprotected = !pProtect->isOptionEnabled(ScTableProtection::SELECT_UNLOCKED_CELLS);
1069 : }
1070 :
1071 0 : if ( bSkipProtected && bSkipUnprotected )
1072 0 : return;
1073 :
1074 : SCsCOL nOldX;
1075 : SCsROW nOldY;
1076 : SCsCOL nCurX;
1077 : SCsROW nCurY;
1078 0 : if ( aViewData.IsRefMode() )
1079 : {
1080 0 : nOldX = (SCsCOL) aViewData.GetRefEndX();
1081 0 : nOldY = (SCsROW) aViewData.GetRefEndY();
1082 0 : nCurX = nOldX + nMovX;
1083 0 : nCurY = nOldY + nMovY;
1084 : }
1085 : else
1086 : {
1087 0 : nOldX = (SCsCOL) aViewData.GetCurX();
1088 0 : nOldY = (SCsROW) aViewData.GetCurY();
1089 0 : nCurX = (nMovX != 0) ? nOldX+nMovX : (SCsCOL) aViewData.GetOldCurX();
1090 0 : nCurY = (nMovY != 0) ? nOldY+nMovY : (SCsROW) aViewData.GetOldCurY();
1091 : }
1092 :
1093 0 : aViewData.ResetOldCursor();
1094 :
1095 0 : if (nMovX != 0 && ValidColRow(nCurX,nCurY))
1096 0 : SkipCursorHorizontal(nCurX, nCurY, nOldX, nMovX);
1097 :
1098 0 : if (nMovY != 0 && ValidColRow(nCurX,nCurY))
1099 0 : SkipCursorVertical(nCurX, nCurY, nOldY, nMovY);
1100 :
1101 0 : MoveCursorAbs( nCurX, nCurY, eMode, bShift, false, true, bKeepSel );
1102 : }
1103 :
1104 0 : void ScTabView::MoveCursorPage( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, bool bShift, bool bKeepSel )
1105 : {
1106 : SCsCOL nPageX;
1107 : SCsROW nPageY;
1108 0 : GetPageMoveEndPosition(nMovX, nMovY, nPageX, nPageY);
1109 0 : MoveCursorRel( nPageX, nPageY, eMode, bShift, bKeepSel );
1110 0 : }
1111 :
1112 0 : void ScTabView::MoveCursorArea( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, bool bShift, bool bKeepSel )
1113 : {
1114 : SCsCOL nNewX;
1115 : SCsROW nNewY;
1116 0 : GetAreaMoveEndPosition(nMovX, nMovY, eMode, nNewX, nNewY, eMode);
1117 0 : MoveCursorRel(nNewX, nNewY, eMode, bShift, bKeepSel);
1118 0 : }
1119 :
1120 0 : void ScTabView::MoveCursorEnd( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, bool bShift, bool bKeepSel )
1121 : {
1122 0 : ScDocument* pDoc = aViewData.GetDocument();
1123 0 : SCTAB nTab = aViewData.GetTabNo();
1124 :
1125 : SCCOL nCurX;
1126 : SCROW nCurY;
1127 0 : aViewData.GetMoveCursor( nCurX,nCurY );
1128 0 : SCCOL nNewX = nCurX;
1129 0 : SCROW nNewY = nCurY;
1130 :
1131 0 : SCCOL nUsedX = 0;
1132 0 : SCROW nUsedY = 0;
1133 0 : if ( nMovX > 0 || nMovY > 0 )
1134 0 : pDoc->GetPrintArea( nTab, nUsedX, nUsedY ); // Ende holen
1135 :
1136 0 : if (nMovX<0)
1137 0 : nNewX=0;
1138 0 : else if (nMovX>0)
1139 0 : nNewX=nUsedX; // letzter benutzter Bereich
1140 :
1141 0 : if (nMovY<0)
1142 0 : nNewY=0;
1143 0 : else if (nMovY>0)
1144 0 : nNewY=nUsedY;
1145 :
1146 0 : aViewData.ResetOldCursor();
1147 0 : MoveCursorRel( ((SCsCOL)nNewX)-(SCsCOL)nCurX, ((SCsROW)nNewY)-(SCsROW)nCurY, eMode, bShift, bKeepSel );
1148 0 : }
1149 :
1150 0 : void ScTabView::MoveCursorScreen( SCsCOL nMovX, SCsROW nMovY, ScFollowMode eMode, bool bShift )
1151 : {
1152 0 : ScDocument* pDoc = aViewData.GetDocument();
1153 0 : SCTAB nTab = aViewData.GetTabNo();
1154 :
1155 : SCCOL nCurX;
1156 : SCROW nCurY;
1157 0 : aViewData.GetMoveCursor( nCurX,nCurY );
1158 0 : SCCOL nNewX = nCurX;
1159 0 : SCROW nNewY = nCurY;
1160 :
1161 0 : ScSplitPos eWhich = aViewData.GetActivePart();
1162 0 : SCCOL nPosX = aViewData.GetPosX( WhichH(eWhich) );
1163 0 : SCROW nPosY = aViewData.GetPosY( WhichV(eWhich) );
1164 :
1165 0 : SCCOL nAddX = aViewData.VisibleCellsX( WhichH(eWhich) );
1166 0 : if (nAddX != 0)
1167 0 : --nAddX;
1168 0 : SCROW nAddY = aViewData.VisibleCellsY( WhichV(eWhich) );
1169 0 : if (nAddY != 0)
1170 0 : --nAddY;
1171 :
1172 0 : if (nMovX<0)
1173 0 : nNewX=nPosX;
1174 0 : else if (nMovX>0)
1175 0 : nNewX=nPosX+nAddX;
1176 :
1177 0 : if (nMovY<0)
1178 0 : nNewY=nPosY;
1179 0 : else if (nMovY>0)
1180 0 : nNewY=nPosY+nAddY;
1181 :
1182 0 : aViewData.SetOldCursor( nNewX,nNewY );
1183 0 : pDoc->SkipOverlapped(nNewX, nNewY, nTab);
1184 0 : MoveCursorAbs( nNewX, nNewY, eMode, bShift, false, true );
1185 0 : }
1186 :
1187 0 : void ScTabView::MoveCursorEnter( bool bShift ) // bShift -> hoch/runter
1188 : {
1189 0 : const ScInputOptions& rOpt = SC_MOD()->GetInputOptions();
1190 0 : if (!rOpt.GetMoveSelection())
1191 : {
1192 0 : aViewData.UpdateInputHandler(true);
1193 0 : return;
1194 : }
1195 :
1196 0 : SCsCOL nMoveX = 0;
1197 0 : SCsROW nMoveY = 0;
1198 0 : switch ((ScDirection)rOpt.GetMoveDir())
1199 : {
1200 : case DIR_BOTTOM:
1201 0 : nMoveY = bShift ? -1 : 1;
1202 0 : break;
1203 : case DIR_RIGHT:
1204 0 : nMoveX = bShift ? -1 : 1;
1205 0 : break;
1206 : case DIR_TOP:
1207 0 : nMoveY = bShift ? 1 : -1;
1208 0 : break;
1209 : case DIR_LEFT:
1210 0 : nMoveX = bShift ? 1 : -1;
1211 0 : break;
1212 : }
1213 :
1214 0 : ScMarkData& rMark = aViewData.GetMarkData();
1215 0 : if (rMark.IsMarked() || rMark.IsMultiMarked())
1216 : {
1217 : SCCOL nCurX;
1218 : SCROW nCurY;
1219 0 : aViewData.GetMoveCursor( nCurX,nCurY );
1220 0 : SCCOL nNewX = nCurX;
1221 0 : SCROW nNewY = nCurY;
1222 0 : SCTAB nTab = aViewData.GetTabNo();
1223 :
1224 0 : ScDocument* pDoc = aViewData.GetDocument();
1225 0 : pDoc->GetNextPos( nNewX,nNewY, nTab, nMoveX,nMoveY, true, false, rMark );
1226 :
1227 : MoveCursorRel( ((SCsCOL)nNewX)-(SCsCOL)nCurX, ((SCsROW)nNewY)-(SCsROW)nCurY,
1228 0 : SC_FOLLOW_LINE, false, true );
1229 :
1230 : // update input line even if cursor was not moved
1231 0 : if ( nNewX == nCurX && nNewY == nCurY )
1232 0 : aViewData.UpdateInputHandler(true);
1233 : }
1234 : else
1235 : {
1236 0 : if ( nMoveY != 0 && !nMoveX )
1237 : {
1238 : // nach Tab und Enter wieder zur Ausgangsspalte
1239 0 : SCCOL nTabCol = aViewData.GetTabStartCol();
1240 0 : if (nTabCol != SC_TABSTART_NONE)
1241 : {
1242 : SCCOL nCurX;
1243 : SCROW nCurY;
1244 0 : aViewData.GetMoveCursor( nCurX,nCurY );
1245 0 : nMoveX = ((SCsCOL)nTabCol)-(SCsCOL)nCurX;
1246 : }
1247 : }
1248 :
1249 0 : MoveCursorRel( nMoveX,nMoveY, SC_FOLLOW_LINE, false );
1250 : }
1251 : }
1252 :
1253 :
1254 0 : bool ScTabView::MoveCursorKeyInput( const KeyEvent& rKeyEvent )
1255 : {
1256 0 : const KeyCode& rKCode = rKeyEvent.GetKeyCode();
1257 :
1258 : enum { MOD_NONE, MOD_CTRL, MOD_ALT, MOD_BOTH } eModifier =
1259 0 : rKCode.IsMod1() ?
1260 0 : (rKCode.IsMod2() ? MOD_BOTH : MOD_CTRL) :
1261 0 : (rKCode.IsMod2() ? MOD_ALT : MOD_NONE);
1262 :
1263 0 : bool bSel = rKCode.IsShift();
1264 0 : sal_uInt16 nCode = rKCode.GetCode();
1265 :
1266 : // CURSOR keys
1267 0 : SCsCOL nDX = 0;
1268 0 : SCsROW nDY = 0;
1269 0 : switch( nCode )
1270 : {
1271 0 : case KEY_LEFT: nDX = -1; break;
1272 0 : case KEY_RIGHT: nDX = 1; break;
1273 0 : case KEY_UP: nDY = -1; break;
1274 0 : case KEY_DOWN: nDY = 1; break;
1275 : }
1276 0 : if( nDX != 0 || nDY != 0 )
1277 : {
1278 0 : switch( eModifier )
1279 : {
1280 0 : case MOD_NONE: MoveCursorRel( nDX, nDY, SC_FOLLOW_LINE, bSel ); break;
1281 0 : case MOD_CTRL: MoveCursorArea( nDX, nDY, SC_FOLLOW_JUMP, bSel ); break;
1282 : default:
1283 : {
1284 : // added to avoid warnings
1285 : }
1286 : }
1287 : // always true to suppress changes of col/row size (ALT+CURSOR)
1288 0 : return true;
1289 : }
1290 :
1291 : // PAGEUP/PAGEDOWN
1292 0 : if( (nCode == KEY_PAGEUP) || (nCode == KEY_PAGEDOWN) )
1293 : {
1294 0 : nDX = (nCode == KEY_PAGEUP) ? -1 : 1;
1295 0 : switch( eModifier )
1296 : {
1297 0 : case MOD_NONE: MoveCursorPage( 0, static_cast<SCsCOLROW>(nDX), SC_FOLLOW_FIX, bSel ); break;
1298 0 : case MOD_ALT: MoveCursorPage( nDX, 0, SC_FOLLOW_FIX, bSel ); break;
1299 0 : case MOD_CTRL: SelectNextTab( nDX ); break;
1300 : default:
1301 : {
1302 : // added to avoid warnings
1303 : }
1304 : }
1305 0 : return true;
1306 : }
1307 :
1308 : // HOME/END
1309 0 : if( (nCode == KEY_HOME) || (nCode == KEY_END) )
1310 : {
1311 0 : nDX = (nCode == KEY_HOME) ? -1 : 1;
1312 0 : ScFollowMode eMode = (nCode == KEY_HOME) ? SC_FOLLOW_LINE : SC_FOLLOW_JUMP;
1313 0 : switch( eModifier )
1314 : {
1315 0 : case MOD_NONE: MoveCursorEnd( nDX, 0, eMode, bSel ); break;
1316 0 : case MOD_CTRL: MoveCursorEnd( nDX, static_cast<SCsCOLROW>(nDX), eMode, bSel ); break;
1317 : default:
1318 : {
1319 : // added to avoid warnings
1320 : }
1321 : }
1322 0 : return true;
1323 : }
1324 :
1325 0 : return false;
1326 : }
1327 :
1328 :
1329 : // naechste/vorherige nicht geschuetzte Zelle
1330 0 : void ScTabView::FindNextUnprot( bool bShift, bool bInSelection )
1331 : {
1332 0 : short nMove = bShift ? -1 : 1;
1333 :
1334 0 : ScMarkData& rMark = aViewData.GetMarkData();
1335 0 : bool bMarked = bInSelection && (rMark.IsMarked() || rMark.IsMultiMarked());
1336 :
1337 : SCCOL nCurX;
1338 : SCROW nCurY;
1339 0 : aViewData.GetMoveCursor( nCurX,nCurY );
1340 0 : SCCOL nNewX = nCurX;
1341 0 : SCROW nNewY = nCurY;
1342 0 : SCTAB nTab = aViewData.GetTabNo();
1343 :
1344 0 : ScDocument* pDoc = aViewData.GetDocument();
1345 0 : pDoc->GetNextPos( nNewX,nNewY, nTab, nMove,0, bMarked, true, rMark );
1346 :
1347 0 : SCCOL nTabCol = aViewData.GetTabStartCol();
1348 0 : if ( nTabCol == SC_TABSTART_NONE )
1349 0 : nTabCol = nCurX; // auf diese Spalte zurueck bei Enter
1350 :
1351 : MoveCursorRel( ((SCsCOL)nNewX)-(SCsCOL)nCurX, ((SCsROW)nNewY)-(SCsROW)nCurY,
1352 0 : SC_FOLLOW_LINE, false, true );
1353 :
1354 : // in MoveCursorRel wird die TabCol zurueckgesetzt...
1355 0 : aViewData.SetTabStartCol( nTabCol );
1356 0 : }
1357 :
1358 0 : void ScTabView::MarkColumns()
1359 : {
1360 : SCCOL nStartCol;
1361 : SCCOL nEndCol;
1362 :
1363 0 : ScMarkData& rMark = aViewData.GetMarkData();
1364 0 : if (rMark.IsMarked())
1365 : {
1366 0 : ScRange aMarkRange;
1367 0 : rMark.GetMarkArea( aMarkRange );
1368 0 : nStartCol = aMarkRange.aStart.Col();
1369 0 : nEndCol = aMarkRange.aEnd.Col();
1370 : }
1371 : else
1372 : {
1373 : SCROW nDummy;
1374 0 : aViewData.GetMoveCursor( nStartCol, nDummy );
1375 0 : nEndCol=nStartCol;
1376 : }
1377 :
1378 0 : SCTAB nTab = aViewData.GetTabNo();
1379 0 : DoneBlockMode();
1380 0 : InitBlockMode( nStartCol,0, nTab );
1381 0 : MarkCursor( nEndCol,MAXROW, nTab );
1382 0 : SelectionChanged();
1383 0 : }
1384 :
1385 0 : void ScTabView::MarkRows()
1386 : {
1387 : SCROW nStartRow;
1388 : SCROW nEndRow;
1389 :
1390 0 : ScMarkData& rMark = aViewData.GetMarkData();
1391 0 : if (rMark.IsMarked())
1392 : {
1393 0 : ScRange aMarkRange;
1394 0 : rMark.GetMarkArea( aMarkRange );
1395 0 : nStartRow = aMarkRange.aStart.Row();
1396 0 : nEndRow = aMarkRange.aEnd.Row();
1397 : }
1398 : else
1399 : {
1400 : SCCOL nDummy;
1401 0 : aViewData.GetMoveCursor( nDummy, nStartRow );
1402 0 : nEndRow=nStartRow;
1403 : }
1404 :
1405 0 : SCTAB nTab = aViewData.GetTabNo();
1406 0 : DoneBlockMode();
1407 0 : InitBlockMode( 0,nStartRow, nTab );
1408 0 : MarkCursor( MAXCOL,nEndRow, nTab );
1409 0 : SelectionChanged();
1410 0 : }
1411 :
1412 0 : void ScTabView::MarkDataArea( bool bIncludeCursor )
1413 : {
1414 0 : ScDocument* pDoc = aViewData.GetDocument();
1415 0 : SCTAB nTab = aViewData.GetTabNo();
1416 0 : SCCOL nStartCol = aViewData.GetCurX();
1417 0 : SCROW nStartRow = aViewData.GetCurY();
1418 0 : SCCOL nEndCol = nStartCol;
1419 0 : SCROW nEndRow = nStartRow;
1420 :
1421 0 : pDoc->GetDataArea( nTab, nStartCol, nStartRow, nEndCol, nEndRow, bIncludeCursor, false );
1422 :
1423 0 : HideAllCursors();
1424 0 : DoneBlockMode();
1425 0 : InitBlockMode( nStartCol, nStartRow, nTab );
1426 0 : MarkCursor( nEndCol, nEndRow, nTab );
1427 0 : ShowAllCursors();
1428 :
1429 0 : SelectionChanged();
1430 0 : }
1431 :
1432 0 : void ScTabView::MarkMatrixFormula()
1433 : {
1434 0 : ScDocument* pDoc = aViewData.GetDocument();
1435 0 : ScAddress aCursor( aViewData.GetCurX(), aViewData.GetCurY(), aViewData.GetTabNo() );
1436 0 : ScRange aMatrix;
1437 0 : if ( pDoc->GetMatrixFormulaRange( aCursor, aMatrix ) )
1438 : {
1439 0 : MarkRange( aMatrix, false ); // cursor is already within the range
1440 : }
1441 0 : }
1442 :
1443 0 : void ScTabView::MarkRange( const ScRange& rRange, bool bSetCursor, bool bContinue )
1444 : {
1445 0 : SCTAB nTab = rRange.aStart.Tab();
1446 0 : SetTabNo( nTab );
1447 :
1448 0 : HideAllCursors();
1449 0 : DoneBlockMode( bContinue ); // bContinue==true -> clear old mark
1450 0 : if (bSetCursor) // Wenn Cursor gesetzt wird, immer auch alignen
1451 : {
1452 0 : SCCOL nAlignX = rRange.aStart.Col();
1453 0 : SCROW nAlignY = rRange.aStart.Row();
1454 0 : bool bCol = ( rRange.aStart.Col() == 0 && rRange.aEnd.Col() == MAXCOL ) && !aViewData.GetDocument()->IsInVBAMode();
1455 0 : bool bRow = ( rRange.aStart.Row() == 0 && rRange.aEnd.Row() == MAXROW );
1456 0 : if ( bCol )
1457 0 : nAlignX = aViewData.GetPosX(WhichH(aViewData.GetActivePart()));
1458 0 : if ( bRow )
1459 0 : nAlignY = aViewData.GetPosY(WhichV(aViewData.GetActivePart()));
1460 0 : AlignToCursor( nAlignX, nAlignY, SC_FOLLOW_JUMP );
1461 : }
1462 0 : InitBlockMode( rRange.aStart.Col(), rRange.aStart.Row(), nTab );
1463 0 : MarkCursor( rRange.aEnd.Col(), rRange.aEnd.Row(), nTab );
1464 0 : if (bSetCursor)
1465 : {
1466 0 : SCCOL nPosX = rRange.aStart.Col();
1467 0 : SCROW nPosY = rRange.aStart.Row();
1468 0 : ScDocument* pDoc = aViewData.GetDocument();
1469 0 : pDoc->SkipOverlapped(nPosX, nPosY, nTab);
1470 :
1471 0 : aViewData.ResetOldCursor();
1472 0 : SetCursor( nPosX, nPosY );
1473 : }
1474 0 : ShowAllCursors();
1475 :
1476 0 : SelectionChanged();
1477 0 : }
1478 :
1479 0 : void ScTabView::Unmark()
1480 : {
1481 0 : ScMarkData& rMark = aViewData.GetMarkData();
1482 0 : if ( rMark.IsMarked() || rMark.IsMultiMarked() )
1483 : {
1484 : SCCOL nCurX;
1485 : SCROW nCurY;
1486 0 : aViewData.GetMoveCursor( nCurX,nCurY );
1487 0 : MoveCursorAbs( nCurX, nCurY, SC_FOLLOW_NONE, false, false );
1488 :
1489 0 : SelectionChanged();
1490 : }
1491 0 : }
1492 :
1493 0 : void ScTabView::SetMarkData( const ScMarkData& rNew )
1494 : {
1495 0 : DoneBlockMode();
1496 0 : InitOwnBlockMode();
1497 0 : aViewData.GetMarkData() = rNew;
1498 :
1499 0 : MarkDataChanged();
1500 0 : }
1501 :
1502 0 : void ScTabView::MarkDataChanged()
1503 : {
1504 : // has to be called after making direct changes to mark data (not via MarkCursor etc)
1505 :
1506 0 : UpdateSelectionOverlay();
1507 0 : }
1508 :
1509 0 : void ScTabView::SelectNextTab( short nDir, bool bExtendSelection )
1510 : {
1511 0 : if (!nDir) return;
1512 : OSL_ENSURE( nDir==-1 || nDir==1, "SelectNextTab: falscher Wert");
1513 :
1514 0 : ScDocument* pDoc = aViewData.GetDocument();
1515 0 : SCTAB nTab = aViewData.GetTabNo();
1516 0 : if (nDir<0)
1517 : {
1518 0 : if (!nTab) return;
1519 0 : --nTab;
1520 0 : while (!pDoc->IsVisible(nTab))
1521 : {
1522 0 : if (!nTab) return;
1523 0 : --nTab;
1524 : }
1525 : }
1526 : else
1527 : {
1528 0 : SCTAB nCount = pDoc->GetTableCount();
1529 0 : ++nTab;
1530 0 : if (nTab >= nCount) return;
1531 0 : while (!pDoc->IsVisible(nTab))
1532 : {
1533 0 : ++nTab;
1534 0 : if (nTab >= nCount) return;
1535 : }
1536 : }
1537 :
1538 0 : SetTabNo( nTab, false, bExtendSelection );
1539 0 : PaintExtras();
1540 : }
1541 :
1542 :
1543 : // SetTabNo - angezeigte Tabelle
1544 :
1545 0 : void ScTabView::SetTabNo( SCTAB nTab, bool bNew, bool bExtendSelection, bool bSameTabButMoved )
1546 : {
1547 0 : if ( !ValidTab(nTab) )
1548 : {
1549 : OSL_FAIL("SetTabNo: falsche Tabelle");
1550 0 : return;
1551 : }
1552 :
1553 0 : if ( nTab != aViewData.GetTabNo() || bNew )
1554 : {
1555 : // Die FormShell moechte vor dem Umschalten benachrichtigt werden
1556 0 : FmFormShell* pFormSh = aViewData.GetViewShell()->GetFormShell();
1557 0 : if (pFormSh)
1558 : {
1559 0 : bool bAllowed = pFormSh->PrepareClose(true);
1560 0 : if (!bAllowed)
1561 : {
1562 : //! Fehlermeldung? oder macht das die FormShell selber?
1563 : //! Fehler-Flag zurueckgeben und Aktionen abbrechen
1564 :
1565 0 : return; // Die FormShell sagt, es kann nicht umgeschaltet werden
1566 : }
1567 : }
1568 :
1569 : // nicht InputEnterHandler wegen Referenzeingabe !
1570 :
1571 0 : ScDocument* pDoc = aViewData.GetDocument();
1572 :
1573 0 : pDoc->MakeTable( nTab );
1574 :
1575 : // Update pending row heights before switching the sheet, so Reschedule from the progress bar
1576 : // doesn't paint the new sheet with old heights
1577 0 : aViewData.GetDocShell()->UpdatePendingRowHeights( nTab );
1578 :
1579 0 : SCTAB nTabCount = pDoc->GetTableCount();
1580 0 : SCTAB nOldPos = nTab;
1581 0 : while (!pDoc->IsVisible(nTab)) // naechste sichtbare suchen
1582 : {
1583 0 : bool bUp = (nTab>=nOldPos);
1584 0 : if (bUp)
1585 : {
1586 0 : ++nTab;
1587 0 : if (nTab>=nTabCount)
1588 : {
1589 0 : nTab = nOldPos;
1590 0 : bUp = false;
1591 : }
1592 : }
1593 :
1594 0 : if (!bUp)
1595 : {
1596 0 : if (nTab != 0)
1597 0 : --nTab;
1598 : else
1599 : {
1600 : OSL_FAIL("keine sichtbare Tabelle");
1601 0 : pDoc->SetVisible( 0, true );
1602 : }
1603 : }
1604 : }
1605 :
1606 : // #i71490# Deselect drawing objects before changing the sheet number in view data,
1607 : // so the handling of notes still has the sheet selected on which the notes are.
1608 0 : DrawDeselectAll();
1609 :
1610 0 : ScModule* pScMod = SC_MOD();
1611 0 : bool bRefMode = pScMod->IsFormulaMode();
1612 0 : if ( !bRefMode ) // Abfrage, damit RefMode bei Tabellenwechsel funktioniert
1613 : {
1614 0 : DoneBlockMode();
1615 0 : pSelEngine->Reset(); // reset all flags, including locked modifiers
1616 0 : aViewData.SetRefTabNo( nTab );
1617 : }
1618 :
1619 0 : ScSplitPos eOldActive = aViewData.GetActivePart(); // before switching
1620 0 : bool bFocus = pGridWin[eOldActive]->HasFocus();
1621 :
1622 0 : aViewData.SetTabNo( nTab );
1623 : // UpdateShow noch vor SetCursor, damit UpdateAutoFillMark die richtigen
1624 : // Fenster findet (wird aus SetCursor gerufen)
1625 0 : UpdateShow();
1626 0 : aViewData.ResetOldCursor();
1627 :
1628 0 : SfxBindings& rBindings = aViewData.GetBindings();
1629 0 : ScMarkData& rMark = aViewData.GetMarkData();
1630 :
1631 0 : bool bAllSelected = true;
1632 0 : for (SCTAB nSelTab = 0; nSelTab < nTabCount; ++nSelTab)
1633 : {
1634 0 : if (!pDoc->IsVisible(nSelTab) || rMark.GetTableSelect(nSelTab))
1635 : {
1636 0 : if (nTab == nSelTab)
1637 : // This tab is already in selection. Keep the current
1638 : // selection.
1639 0 : bExtendSelection = true;
1640 : }
1641 : else
1642 : {
1643 0 : bAllSelected = false;
1644 0 : if (bExtendSelection)
1645 : // We got what we need. No need to stay in the loop.
1646 0 : break;
1647 : }
1648 : }
1649 0 : if (bAllSelected && !bNew)
1650 : // #i6327# if all tables are selected, a selection event (#i6330#) will deselect all
1651 : // (not if called with bNew to update settings)
1652 0 : bExtendSelection = false;
1653 :
1654 0 : if (bExtendSelection)
1655 0 : rMark.SelectTable( nTab, true );
1656 : else
1657 : {
1658 0 : rMark.SelectOneTable( nTab );
1659 0 : rBindings.Invalidate( FID_FILL_TAB );
1660 0 : rBindings.Invalidate( FID_TAB_DESELECTALL );
1661 : }
1662 :
1663 0 : SetCursor( aViewData.GetCurX(), aViewData.GetCurY(), true );
1664 0 : bool bUnoRefDialog = pScMod->IsRefDialogOpen() && pScMod->GetCurRefDlgId() == WID_SIMPLE_REF;
1665 :
1666 : // recalc zoom-dependent values (before TabChanged, before UpdateEditViewPos)
1667 0 : RefreshZoom();
1668 0 : UpdateVarZoom();
1669 :
1670 0 : if ( bRefMode ) // hide EditView if necessary (after aViewData.SetTabNo !)
1671 : {
1672 0 : for (sal_uInt16 i = 0; i < 4; ++i)
1673 0 : if (pGridWin[i] && pGridWin[i]->IsVisible())
1674 0 : pGridWin[i]->UpdateEditViewPos();
1675 : }
1676 :
1677 0 : TabChanged(bSameTabButMoved); // DrawView
1678 0 : UpdateVisibleRange();
1679 :
1680 0 : aViewData.GetViewShell()->WindowChanged(); // falls das aktive Fenster anders ist
1681 0 : if ( !bUnoRefDialog )
1682 0 : aViewData.GetViewShell()->DisconnectAllClients(); // important for floating frames
1683 : else
1684 : {
1685 : // hide / show inplace client
1686 :
1687 0 : ScClient* pClient = static_cast<ScClient*>(aViewData.GetViewShell()->GetIPClient());
1688 0 : if ( pClient && pClient->IsObjectInPlaceActive() )
1689 : {
1690 0 : Rectangle aObjArea = pClient->GetObjArea();
1691 0 : if ( nTab == aViewData.GetRefTabNo() )
1692 : {
1693 : // move to its original position
1694 :
1695 0 : SdrOle2Obj* pDrawObj = pClient->GetDrawObj();
1696 0 : if ( pDrawObj )
1697 : {
1698 0 : Rectangle aRect = pDrawObj->GetLogicRect();
1699 0 : MapMode aMapMode( MAP_100TH_MM );
1700 0 : Size aOleSize = pDrawObj->GetOrigObjSize( &aMapMode );
1701 0 : aRect.SetSize( aOleSize );
1702 0 : aObjArea = aRect;
1703 : }
1704 : }
1705 : else
1706 : {
1707 : // move to an invisible position
1708 :
1709 0 : aObjArea.SetPos( Point( 0, -2*aObjArea.GetHeight() ) );
1710 : }
1711 0 : pClient->SetObjArea( aObjArea );
1712 : }
1713 : }
1714 :
1715 0 : if ( bFocus && aViewData.GetActivePart() != eOldActive && !bRefMode )
1716 0 : ActiveGrabFocus(); // grab focus to the pane that's active now
1717 :
1718 : // Fixierungen
1719 :
1720 0 : bool bResize = false;
1721 0 : if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX )
1722 0 : if (aViewData.UpdateFixX())
1723 0 : bResize = true;
1724 0 : if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX )
1725 0 : if (aViewData.UpdateFixY())
1726 0 : bResize = true;
1727 0 : if (bResize)
1728 0 : RepeatResize();
1729 0 : InvalidateSplit();
1730 :
1731 0 : if ( aViewData.IsPagebreakMode() )
1732 0 : UpdatePageBreakData(); //! asynchron ??
1733 :
1734 : // Form-Layer muss den sichtbaren Ausschnitt der neuen Tabelle kennen
1735 : // dafuer muss hier schon der MapMode stimmen
1736 0 : for (sal_uInt16 i=0; i<4; i++)
1737 0 : if (pGridWin[i])
1738 0 : pGridWin[i]->SetMapMode( pGridWin[i]->GetDrawMapMode() );
1739 0 : SetNewVisArea();
1740 :
1741 0 : PaintGrid();
1742 0 : PaintTop();
1743 0 : PaintLeft();
1744 0 : PaintExtras();
1745 :
1746 0 : DoResize( aBorderPos, aFrameSize );
1747 0 : rBindings.Invalidate( SID_DELETE_PRINTAREA ); // Menue
1748 0 : rBindings.Invalidate( FID_DEL_MANUALBREAKS );
1749 0 : rBindings.Invalidate( FID_RESET_PRINTZOOM );
1750 0 : rBindings.Invalidate( SID_STATUS_DOCPOS ); // Statusbar
1751 0 : rBindings.Invalidate( SID_ROWCOL_SELCOUNT ); // Statusbar
1752 0 : rBindings.Invalidate( SID_STATUS_PAGESTYLE ); // Statusbar
1753 0 : rBindings.Invalidate( SID_CURRENTTAB ); // Navigator
1754 0 : rBindings.Invalidate( SID_STYLE_FAMILY2 ); // Gestalter
1755 0 : rBindings.Invalidate( SID_STYLE_FAMILY4 ); // Gestalter
1756 0 : rBindings.Invalidate( SID_TABLES_COUNT );
1757 :
1758 0 : if(pScMod->IsRefDialogOpen())
1759 : {
1760 0 : sal_uInt16 nCurRefDlgId=pScMod->GetCurRefDlgId();
1761 0 : SfxViewFrame* pViewFrm = aViewData.GetViewShell()->GetViewFrame();
1762 0 : SfxChildWindow* pChildWnd = pViewFrm->GetChildWindow( nCurRefDlgId );
1763 0 : if ( pChildWnd )
1764 : {
1765 0 : IAnyRefDialog* pRefDlg = dynamic_cast<IAnyRefDialog*>(pChildWnd->GetWindow());
1766 0 : pRefDlg->ViewShellChanged();
1767 : }
1768 : }
1769 : }
1770 : }
1771 :
1772 :
1773 : // Paint-Funktionen - nur fuer diese View
1774 :
1775 :
1776 0 : void ScTabView::MakeEditView( ScEditEngineDefaulter* pEngine, SCCOL nCol, SCROW nRow )
1777 : {
1778 0 : DrawDeselectAll();
1779 :
1780 0 : if (pDrawView)
1781 0 : DrawEnableAnim( false );
1782 :
1783 0 : EditView* pSpellingView = aViewData.GetSpellingView();
1784 :
1785 0 : for (sal_uInt16 i=0; i<4; i++)
1786 0 : if (pGridWin[i])
1787 0 : if ( pGridWin[i]->IsVisible() && !aViewData.HasEditView((ScSplitPos)i) )
1788 : {
1789 0 : ScHSplitPos eHWhich = WhichH( (ScSplitPos) i );
1790 0 : ScVSplitPos eVWhich = WhichV( (ScSplitPos) i );
1791 0 : SCCOL nScrX = aViewData.GetPosX( eHWhich );
1792 0 : SCROW nScrY = aViewData.GetPosY( eVWhich );
1793 :
1794 : bool bPosVisible =
1795 0 : ( nCol >= nScrX && nCol <= nScrX + aViewData.VisibleCellsX(eHWhich) + 1 &&
1796 0 : nRow >= nScrY && nRow <= nScrY + aViewData.VisibleCellsY(eVWhich) + 1 );
1797 :
1798 : // for the active part, create edit view even if outside the visible area,
1799 : // so input isn't lost (and the edit view may be scrolled into the visible area)
1800 :
1801 : // #i26433# during spelling, the spelling view must be active
1802 0 : if ( bPosVisible || aViewData.GetActivePart() == (ScSplitPos) i ||
1803 0 : ( pSpellingView && aViewData.GetEditView((ScSplitPos) i) == pSpellingView ) )
1804 : {
1805 0 : pGridWin[i]->HideCursor();
1806 :
1807 0 : pGridWin[i]->DeleteCursorOverlay();
1808 0 : pGridWin[i]->DeleteAutoFillOverlay();
1809 0 : pGridWin[i]->DeleteCopySourceOverlay();
1810 :
1811 : // flush OverlayManager before changing MapMode to text edit
1812 0 : pGridWin[i]->flushOverlayManager();
1813 :
1814 : // MapMode must be set after HideCursor
1815 0 : pGridWin[i]->SetMapMode(aViewData.GetLogicMode());
1816 :
1817 0 : aViewData.SetEditEngine( (ScSplitPos) i, pEngine, pGridWin[i], nCol, nRow );
1818 :
1819 0 : if ( !bPosVisible )
1820 : {
1821 : // move the edit view area to the real (possibly negative) position,
1822 : // or hide if completely above or left of the window
1823 0 : pGridWin[i]->UpdateEditViewPos();
1824 : }
1825 : }
1826 : }
1827 :
1828 0 : if (aViewData.GetViewShell()->HasAccessibilityObjects())
1829 0 : aViewData.GetViewShell()->BroadcastAccessibility(SfxSimpleHint(SC_HINT_ACC_ENTEREDITMODE));
1830 0 : }
1831 :
1832 0 : void ScTabView::UpdateEditView()
1833 : {
1834 0 : ScSplitPos eActive = aViewData.GetActivePart();
1835 0 : for (sal_uInt16 i=0; i<4; i++)
1836 0 : if (aViewData.HasEditView( (ScSplitPos) i ))
1837 : {
1838 0 : EditView* pEditView = aViewData.GetEditView( (ScSplitPos) i );
1839 : aViewData.SetEditEngine( (ScSplitPos) i,
1840 0 : static_cast<ScEditEngineDefaulter*>(pEditView->GetEditEngine()),
1841 0 : pGridWin[i], GetViewData()->GetCurX(), GetViewData()->GetCurY() );
1842 0 : if ( (ScSplitPos)i == eActive )
1843 0 : pEditView->ShowCursor( false );
1844 : }
1845 0 : }
1846 :
1847 0 : void ScTabView::KillEditView( bool bNoPaint )
1848 : {
1849 : sal_uInt16 i;
1850 0 : SCCOL nCol1 = aViewData.GetEditStartCol();
1851 0 : SCROW nRow1 = aViewData.GetEditStartRow();
1852 0 : SCCOL nCol2 = aViewData.GetEditEndCol();
1853 0 : SCROW nRow2 = aViewData.GetEditEndRow();
1854 : bool bPaint[4];
1855 0 : bool bNotifyAcc = false;
1856 :
1857 0 : bool bExtended = nRow1 != nRow2; // Col wird sowieso bis zum Ende gezeichnet
1858 0 : bool bAtCursor = nCol1 <= aViewData.GetCurX() &&
1859 0 : nCol2 >= aViewData.GetCurX() &&
1860 0 : nRow1 == aViewData.GetCurY();
1861 0 : for (i=0; i<4; i++)
1862 : {
1863 0 : bPaint[i] = aViewData.HasEditView( (ScSplitPos) i );
1864 0 : if (bPaint[i])
1865 0 : bNotifyAcc = true;
1866 : }
1867 :
1868 : // #108931#; notify accessibility before all things happen
1869 0 : if ((bNotifyAcc) && (aViewData.GetViewShell()->HasAccessibilityObjects()))
1870 0 : aViewData.GetViewShell()->BroadcastAccessibility(SfxSimpleHint(SC_HINT_ACC_LEAVEEDITMODE));
1871 :
1872 0 : aViewData.ResetEditView();
1873 0 : for (i=0; i<4; i++)
1874 0 : if (pGridWin[i] && bPaint[i])
1875 0 : if (pGridWin[i]->IsVisible())
1876 : {
1877 0 : pGridWin[i]->ShowCursor();
1878 :
1879 0 : pGridWin[i]->SetMapMode(pGridWin[i]->GetDrawMapMode());
1880 :
1881 : // #i73567# the cell still has to be repainted
1882 0 : if (bExtended || ( bAtCursor && !bNoPaint ))
1883 : {
1884 0 : pGridWin[i]->Draw( nCol1, nRow1, nCol2, nRow2 );
1885 0 : pGridWin[i]->UpdateSelectionOverlay();
1886 : }
1887 : }
1888 :
1889 0 : if (pDrawView)
1890 0 : DrawEnableAnim( true );
1891 :
1892 : // GrabFocus immer dann, wenn diese View aktiv ist und
1893 : // die Eingabezeile den Focus hat
1894 :
1895 0 : bool bGrabFocus = false;
1896 0 : if (aViewData.IsActive())
1897 : {
1898 0 : ScInputHandler* pInputHdl = SC_MOD()->GetInputHdl();
1899 0 : if ( pInputHdl )
1900 : {
1901 0 : ScInputWindow* pInputWin = pInputHdl->GetInputWindow();
1902 0 : if (pInputWin && pInputWin->IsInputActive())
1903 0 : bGrabFocus = true;
1904 : }
1905 : }
1906 :
1907 0 : if (bGrabFocus)
1908 : {
1909 : // So soll es gemacht werden, damit der Sfx es mitbekommt, klappt aber nicht:
1910 : //! aViewData.GetViewShell()->GetViewFrame()->GetWindow().GrabFocus();
1911 : // deshalb erstmal so:
1912 0 : GetActiveWin()->GrabFocus();
1913 : }
1914 :
1915 : // Cursor-Abfrage erst nach GrabFocus
1916 :
1917 0 : for (i=0; i<4; i++)
1918 0 : if (pGridWin[i] && pGridWin[i]->IsVisible())
1919 : {
1920 0 : Cursor* pCur = pGridWin[i]->GetCursor();
1921 0 : if (pCur && pCur->IsVisible())
1922 0 : pCur->Hide();
1923 :
1924 0 : if(bPaint[i])
1925 : {
1926 0 : pGridWin[i]->UpdateCursorOverlay();
1927 0 : pGridWin[i]->UpdateAutoFillOverlay();
1928 : }
1929 : }
1930 0 : }
1931 :
1932 0 : void ScTabView::UpdateFormulas()
1933 : {
1934 0 : if ( aViewData.GetDocument()->IsAutoCalcShellDisabled() )
1935 0 : return ;
1936 :
1937 : sal_uInt16 i;
1938 0 : for (i=0; i<4; i++)
1939 0 : if (pGridWin[i])
1940 0 : if (pGridWin[i]->IsVisible())
1941 0 : pGridWin[i]->UpdateFormulas();
1942 :
1943 0 : if ( aViewData.IsPagebreakMode() )
1944 0 : UpdatePageBreakData(); //! asynchron
1945 :
1946 0 : UpdateHeaderWidth();
1947 :
1948 : // if in edit mode, adjust edit view area because widths/heights may have changed
1949 0 : if ( aViewData.HasEditView( aViewData.GetActivePart() ) )
1950 0 : UpdateEditView();
1951 : }
1952 :
1953 : // PaintArea -Block neu zeichnen
1954 :
1955 0 : void ScTabView::PaintArea( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
1956 : ScUpdateMode eMode )
1957 : {
1958 : SCCOL nCol1;
1959 : SCROW nRow1;
1960 : SCCOL nCol2;
1961 : SCROW nRow2;
1962 :
1963 0 : PutInOrder( nStartCol, nEndCol );
1964 0 : PutInOrder( nStartRow, nEndRow );
1965 :
1966 0 : for (size_t i = 0; i < 4; ++i)
1967 : {
1968 0 : if (!pGridWin[i] || !pGridWin[i]->IsVisible())
1969 0 : continue;
1970 :
1971 0 : ScHSplitPos eHWhich = WhichH( (ScSplitPos) i );
1972 0 : ScVSplitPos eVWhich = WhichV( (ScSplitPos) i );
1973 0 : bool bOut = false;
1974 :
1975 0 : nCol1 = nStartCol;
1976 0 : nRow1 = nStartRow;
1977 0 : nCol2 = nEndCol;
1978 0 : nRow2 = nEndRow;
1979 :
1980 0 : SCCOL nScrX = aViewData.GetPosX( eHWhich );
1981 0 : SCROW nScrY = aViewData.GetPosY( eVWhich );
1982 0 : if (nCol1 < nScrX) nCol1 = nScrX;
1983 0 : if (nCol2 < nScrX)
1984 : {
1985 0 : if ( eMode == SC_UPDATE_ALL ) // for UPDATE_ALL, paint anyway
1986 0 : nCol2 = nScrX; // (because of extending strings to the right)
1987 : else
1988 0 : bOut = true; // completely outside the window
1989 : }
1990 0 : if (nRow1 < nScrY) nRow1 = nScrY;
1991 0 : if (nRow2 < nScrY) bOut = true;
1992 :
1993 0 : SCCOL nLastX = nScrX + aViewData.VisibleCellsX( eHWhich ) + 1;
1994 0 : SCROW nLastY = nScrY + aViewData.VisibleCellsY( eVWhich ) + 1;
1995 0 : if (nCol1 > nLastX) bOut = true;
1996 0 : if (nCol2 > nLastX) nCol2 = nLastX;
1997 0 : if (nRow1 > nLastY) bOut = true;
1998 0 : if (nRow2 > nLastY) nRow2 = nLastY;
1999 :
2000 0 : if (bOut)
2001 0 : continue;
2002 :
2003 0 : if ( eMode == SC_UPDATE_CHANGED )
2004 0 : pGridWin[i]->Draw( nCol1, nRow1, nCol2, nRow2, eMode );
2005 : else // ALL oder MARKS
2006 : {
2007 0 : bool bLayoutRTL = aViewData.GetDocument()->IsLayoutRTL( aViewData.GetTabNo() );
2008 0 : long nLayoutSign = bLayoutRTL ? -1 : 1;
2009 :
2010 0 : Point aStart = aViewData.GetScrPos( nCol1, nRow1, (ScSplitPos) i );
2011 0 : Point aEnd = aViewData.GetScrPos( nCol2+1, nRow2+1, (ScSplitPos) i );
2012 0 : if ( eMode == SC_UPDATE_ALL )
2013 0 : aEnd.X() = bLayoutRTL ? 0 : (pGridWin[i]->GetOutputSizePixel().Width());
2014 0 : aEnd.X() -= nLayoutSign;
2015 0 : aEnd.Y() -= 1;
2016 :
2017 : // #i85232# include area below cells (could be done in GetScrPos?)
2018 0 : if ( eMode == SC_UPDATE_ALL && nRow2 >= MAXROW )
2019 0 : aEnd.Y() = pGridWin[i]->GetOutputSizePixel().Height();
2020 :
2021 0 : aStart.X() -= nLayoutSign; // include change marks
2022 0 : aStart.Y() -= 1;
2023 :
2024 0 : bool bMarkClipped = aViewData.GetOptions().GetOption( VOPT_CLIPMARKS );
2025 0 : if (bMarkClipped)
2026 : {
2027 : // dazu muesste ScColumn::IsEmptyBlock optimiert werden
2028 : // (auf Search() umstellen)
2029 : //!if ( nCol1 > 0 && !aViewData.GetDocument()->IsBlockEmpty(
2030 : //! aViewData.GetTabNo(),
2031 : //! 0, nRow1, nCol1-1, nRow2 ) )
2032 : {
2033 0 : long nMarkPixel = (long)( SC_CLIPMARK_SIZE * aViewData.GetPPTX() );
2034 0 : aStart.X() -= nMarkPixel * nLayoutSign;
2035 : }
2036 : }
2037 :
2038 0 : pGridWin[i]->Invalidate( pGridWin[i]->PixelToLogic( Rectangle( aStart,aEnd ) ) );
2039 : }
2040 : }
2041 :
2042 : // #i79909# Calling UpdateAllOverlays here isn't necessary and would lead to overlay calls from a timer,
2043 : // with a wrong MapMode if editing in a cell (reference input).
2044 : // #i80499# Overlays need updates in a lot of cases, e.g. changing row/column size,
2045 : // or showing/hiding outlines. TODO: selections in inactive windows are vanishing.
2046 : // #i84689# With relative conditional formats, PaintArea may be called often (for each changed cell),
2047 : // so UpdateAllOverlays was moved to ScTabViewShell::Notify and is called only if PAINT_LEFT/PAINT_TOP
2048 : // is set (width or height changed).
2049 0 : }
2050 :
2051 0 : void ScTabView::PaintRangeFinderEntry (ScRangeFindData* pData, const SCTAB nTab)
2052 : {
2053 0 : ScRange aRef = pData->aRef;
2054 0 : aRef.Justify(); // Justify fuer die Abfragen unten
2055 :
2056 0 : if ( aRef.aStart == aRef.aEnd ) //! Tab ignorieren?
2057 0 : aViewData.GetDocument()->ExtendMerge(aRef);
2058 :
2059 0 : if ( aRef.aStart.Tab() >= nTab && aRef.aEnd.Tab() <= nTab )
2060 : {
2061 0 : SCCOL nCol1 = aRef.aStart.Col();
2062 0 : SCROW nRow1 = aRef.aStart.Row();
2063 0 : SCCOL nCol2 = aRef.aEnd.Col();
2064 0 : SCROW nRow2 = aRef.aEnd.Row();
2065 :
2066 : // wegnehmen -> Repaint
2067 : // SC_UPDATE_MARKS: Invalidate, nicht bis zum Zeilenende
2068 :
2069 0 : bool bHiddenEdge = false;
2070 : SCROW nTmp;
2071 0 : ScDocument* pDoc = aViewData.GetDocument();
2072 0 : while ( nCol1 > 0 && pDoc->ColHidden(nCol1, nTab) )
2073 : {
2074 0 : --nCol1;
2075 0 : bHiddenEdge = true;
2076 : }
2077 0 : while ( nCol2 < MAXCOL && pDoc->ColHidden(nCol2, nTab) )
2078 : {
2079 0 : ++nCol2;
2080 0 : bHiddenEdge = true;
2081 : }
2082 0 : nTmp = pDoc->LastVisibleRow(0, nRow1, nTab);
2083 0 : if (!ValidRow(nTmp))
2084 0 : nTmp = 0;
2085 0 : if (nTmp < nRow1)
2086 : {
2087 0 : nRow1 = nTmp;
2088 0 : bHiddenEdge = true;
2089 : }
2090 0 : nTmp = pDoc->FirstVisibleRow(nRow2, MAXROW, nTab);
2091 0 : if (!ValidRow(nTmp))
2092 0 : nTmp = MAXROW;
2093 0 : if (nTmp > nRow2)
2094 : {
2095 0 : nRow2 = nTmp;
2096 0 : bHiddenEdge = true;
2097 : }
2098 :
2099 0 : if ( nCol2 - nCol1 > 1 && nRow2 - nRow1 > 1 && !bHiddenEdge )
2100 : {
2101 : // nur an den Raendern entlang
2102 0 : PaintArea( nCol1, nRow1, nCol2, nRow1, SC_UPDATE_MARKS );
2103 0 : PaintArea( nCol1, nRow1+1, nCol1, nRow2-1, SC_UPDATE_MARKS );
2104 0 : PaintArea( nCol2, nRow1+1, nCol2, nRow2-1, SC_UPDATE_MARKS );
2105 0 : PaintArea( nCol1, nRow2, nCol2, nRow2, SC_UPDATE_MARKS );
2106 : }
2107 : else // alles am Stueck
2108 0 : PaintArea( nCol1, nRow1, nCol2, nRow2, SC_UPDATE_MARKS );
2109 : }
2110 0 : }
2111 :
2112 0 : void ScTabView::UpdateGrid()
2113 : {
2114 0 : if (!aViewData.IsActive())
2115 0 : return;
2116 :
2117 0 : if (!UpdateVisibleRange())
2118 : // Visible range hasn't changed. No need to re-paint.
2119 0 : return;
2120 :
2121 0 : SC_MOD()->AnythingChanged(); // if visible area has changed
2122 0 : PaintGrid();
2123 : }
2124 :
2125 0 : void ScTabView::PaintRangeFinder( long nNumber )
2126 : {
2127 0 : ScInputHandler* pHdl = SC_MOD()->GetInputHdl( aViewData.GetViewShell() );
2128 0 : if (pHdl)
2129 : {
2130 0 : ScRangeFindList* pRangeFinder = pHdl->GetRangeFindList();
2131 0 : if ( pRangeFinder && pRangeFinder->GetDocName() == aViewData.GetDocShell()->GetTitle() )
2132 : {
2133 0 : SCTAB nTab = aViewData.GetTabNo();
2134 0 : sal_uInt16 nCount = (sal_uInt16)pRangeFinder->Count();
2135 :
2136 0 : if (nNumber < 0)
2137 : {
2138 0 : for (sal_uInt16 i=0; i<nCount; i++)
2139 0 : PaintRangeFinderEntry(pRangeFinder->GetObject(i),nTab);
2140 : }
2141 : else
2142 : {
2143 0 : sal_uInt16 idx = nNumber;
2144 0 : if (idx < nCount)
2145 0 : PaintRangeFinderEntry(pRangeFinder->GetObject(idx),nTab);
2146 : }
2147 : }
2148 : }
2149 0 : }
2150 :
2151 : // fuer Chart-Daten-Markierung
2152 :
2153 0 : void ScTabView::AddHighlightRange( const ScRange& rRange, const Color& rColor )
2154 : {
2155 0 : maHighlightRanges.push_back( ScHighlightEntry( rRange, rColor ) );
2156 :
2157 0 : SCTAB nTab = aViewData.GetTabNo();
2158 0 : if ( nTab >= rRange.aStart.Tab() && nTab <= rRange.aEnd.Tab() )
2159 0 : PaintArea( rRange.aStart.Col(), rRange.aStart.Row(),
2160 0 : rRange.aEnd.Col(), rRange.aEnd.Row(), SC_UPDATE_MARKS );
2161 0 : }
2162 :
2163 0 : void ScTabView::ClearHighlightRanges()
2164 : {
2165 0 : SCTAB nTab = aViewData.GetTabNo();
2166 0 : std::vector<ScHighlightEntry>::const_iterator pIter;
2167 0 : for ( pIter = maHighlightRanges.begin(); pIter != maHighlightRanges.end(); ++pIter)
2168 : {
2169 0 : ScRange aRange = pIter->aRef;
2170 0 : if ( nTab >= aRange.aStart.Tab() && nTab <= aRange.aEnd.Tab() )
2171 0 : PaintArea( aRange.aStart.Col(), aRange.aStart.Row(),
2172 0 : aRange.aEnd.Col(), aRange.aEnd.Row(), SC_UPDATE_MARKS );
2173 : }
2174 :
2175 0 : maHighlightRanges.clear();
2176 0 : }
2177 :
2178 0 : void ScTabView::DoChartSelection(
2179 : const uno::Sequence< chart2::data::HighlightedRange > & rHilightRanges )
2180 : {
2181 0 : ClearHighlightRanges();
2182 0 : const sal_Unicode sep = ::formula::FormulaCompiler::GetNativeSymbolChar(ocSep);
2183 :
2184 0 : for( sal_Int32 i=0; i<rHilightRanges.getLength(); ++i )
2185 : {
2186 0 : Color aSelColor( rHilightRanges[i].PreferredColor );
2187 0 : ScRangeList aRangeList;
2188 0 : ScDocument* pDoc = aViewData.GetDocShell()->GetDocument();
2189 0 : if( ScRangeStringConverter::GetRangeListFromString(
2190 0 : aRangeList, rHilightRanges[i].RangeRepresentation, pDoc, pDoc->GetAddressConvention(), sep ))
2191 : {
2192 0 : size_t nListSize = aRangeList.size();
2193 0 : for ( size_t j = 0; j < nListSize; ++j )
2194 : {
2195 0 : ScRange* p = aRangeList[j];
2196 0 : if( rHilightRanges[i].Index == - 1 )
2197 0 : AddHighlightRange( *p, aSelColor );
2198 : else
2199 0 : AddHighlightRange( lcl_getSubRangeByIndex( *p, rHilightRanges[i].Index ), aSelColor );
2200 : }
2201 : }
2202 0 : }
2203 0 : }
2204 :
2205 : // PaintGrid - Datenbereiche neu zeichnen
2206 :
2207 0 : void ScTabView::PaintGrid()
2208 : {
2209 : sal_uInt16 i;
2210 0 : for (i=0; i<4; i++)
2211 0 : if (pGridWin[i])
2212 0 : if (pGridWin[i]->IsVisible())
2213 0 : pGridWin[i]->Invalidate();
2214 0 : }
2215 :
2216 : // PaintTop - obere Kontrollelemente neu zeichnen
2217 :
2218 0 : void ScTabView::PaintTop()
2219 : {
2220 : sal_uInt16 i;
2221 0 : for (i=0; i<2; i++)
2222 : {
2223 0 : if (pColBar[i])
2224 0 : pColBar[i]->Invalidate();
2225 0 : if (pColOutline[i])
2226 0 : pColOutline[i]->Invalidate();
2227 : }
2228 0 : }
2229 :
2230 0 : void ScTabView::CreateAnchorHandles(SdrHdlList& rHdl, const ScAddress& rAddress)
2231 : {
2232 : sal_uInt16 i;
2233 :
2234 0 : for(i=0; i<4; i++)
2235 : {
2236 0 : if(pGridWin[i])
2237 : {
2238 0 : if(pGridWin[i]->IsVisible())
2239 : {
2240 0 : pGridWin[i]->CreateAnchorHandle(rHdl, rAddress);
2241 : }
2242 : }
2243 : }
2244 0 : }
2245 :
2246 0 : void ScTabView::PaintTopArea( SCCOL nStartCol, SCCOL nEndCol )
2247 : {
2248 : // Pixel-Position der linken Kante
2249 :
2250 0 : if ( nStartCol < aViewData.GetPosX(SC_SPLIT_LEFT) ||
2251 0 : nStartCol < aViewData.GetPosX(SC_SPLIT_RIGHT) )
2252 0 : aViewData.RecalcPixPos();
2253 :
2254 : // Fixierung anpassen (UpdateFixX setzt HSplitPos neu)
2255 :
2256 0 : if ( aViewData.GetHSplitMode() == SC_SPLIT_FIX && nStartCol < aViewData.GetFixPosX() )
2257 0 : if (aViewData.UpdateFixX())
2258 0 : RepeatResize();
2259 :
2260 : // zeichnen
2261 :
2262 0 : if (nStartCol>0)
2263 0 : --nStartCol; //! allgemeiner ?
2264 :
2265 0 : bool bLayoutRTL = aViewData.GetDocument()->IsLayoutRTL( aViewData.GetTabNo() );
2266 0 : long nLayoutSign = bLayoutRTL ? -1 : 1;
2267 :
2268 0 : for (sal_uInt16 i=0; i<2; i++)
2269 : {
2270 0 : ScHSplitPos eWhich = (ScHSplitPos) i;
2271 0 : if (pColBar[eWhich])
2272 : {
2273 0 : Size aWinSize = pColBar[eWhich]->GetSizePixel();
2274 0 : long nStartX = aViewData.GetScrPos( nStartCol, 0, eWhich ).X();
2275 : long nEndX;
2276 0 : if (nEndCol >= MAXCOL)
2277 0 : nEndX = bLayoutRTL ? 0 : ( aWinSize.Width()-1 );
2278 : else
2279 0 : nEndX = aViewData.GetScrPos( nEndCol+1, 0, eWhich ).X() - nLayoutSign;
2280 0 : pColBar[eWhich]->Invalidate(
2281 0 : Rectangle( nStartX, 0, nEndX, aWinSize.Height()-1 ) );
2282 : }
2283 0 : if (pColOutline[eWhich])
2284 0 : pColOutline[eWhich]->Invalidate();
2285 : }
2286 0 : }
2287 :
2288 :
2289 : // PaintLeft - linke Kontrollelemente neu zeichnen
2290 :
2291 0 : void ScTabView::PaintLeft()
2292 : {
2293 : sal_uInt16 i;
2294 0 : for (i=0; i<2; i++)
2295 : {
2296 0 : if (pRowBar[i])
2297 0 : pRowBar[i]->Invalidate();
2298 0 : if (pRowOutline[i])
2299 0 : pRowOutline[i]->Invalidate();
2300 : }
2301 0 : }
2302 :
2303 0 : void ScTabView::PaintLeftArea( SCROW nStartRow, SCROW nEndRow )
2304 : {
2305 : // Pixel-Position der oberen Kante
2306 :
2307 0 : if ( nStartRow < aViewData.GetPosY(SC_SPLIT_TOP) ||
2308 0 : nStartRow < aViewData.GetPosY(SC_SPLIT_BOTTOM) )
2309 0 : aViewData.RecalcPixPos();
2310 :
2311 : // Fixierung anpassen (UpdateFixY setzt VSplitPos neu)
2312 :
2313 0 : if ( aViewData.GetVSplitMode() == SC_SPLIT_FIX && nStartRow < aViewData.GetFixPosY() )
2314 0 : if (aViewData.UpdateFixY())
2315 0 : RepeatResize();
2316 :
2317 : // zeichnen
2318 :
2319 0 : if (nStartRow>0)
2320 0 : --nStartRow;
2321 :
2322 0 : for (sal_uInt16 i=0; i<2; i++)
2323 : {
2324 0 : ScVSplitPos eWhich = (ScVSplitPos) i;
2325 0 : if (pRowBar[eWhich])
2326 : {
2327 0 : Size aWinSize = pRowBar[eWhich]->GetSizePixel();
2328 0 : long nStartY = aViewData.GetScrPos( 0, nStartRow, eWhich ).Y();
2329 : long nEndY;
2330 0 : if (nEndRow >= MAXROW)
2331 0 : nEndY = aWinSize.Height()-1;
2332 : else
2333 0 : nEndY = aViewData.GetScrPos( 0, nEndRow+1, eWhich ).Y() - 1;
2334 0 : pRowBar[eWhich]->Invalidate(
2335 0 : Rectangle( 0, nStartY, aWinSize.Width()-1, nEndY ) );
2336 : }
2337 0 : if (pRowOutline[eWhich])
2338 0 : pRowOutline[eWhich]->Invalidate();
2339 : }
2340 0 : }
2341 :
2342 0 : bool ScTabView::PaintExtras()
2343 : {
2344 0 : bool bRet = false;
2345 0 : ScDocument* pDoc = aViewData.GetDocument();
2346 0 : SCTAB nTab = aViewData.GetTabNo();
2347 0 : if (!pDoc->HasTable(nTab)) // Tabelle geloescht ?
2348 : {
2349 0 : SCTAB nCount = pDoc->GetTableCount();
2350 0 : aViewData.SetTabNo(nCount-1);
2351 0 : bRet = true;
2352 : }
2353 0 : pTabControl->UpdateStatus(); // true = active
2354 0 : return bRet;
2355 : }
2356 :
2357 0 : void ScTabView::RecalcPPT()
2358 : {
2359 : // called after changes that require the PPT values to be recalculated
2360 : // (currently from detective operations)
2361 :
2362 0 : double nOldX = aViewData.GetPPTX();
2363 0 : double nOldY = aViewData.GetPPTY();
2364 :
2365 0 : aViewData.RefreshZoom(); // pre-calculate new PPT values
2366 :
2367 0 : bool bChangedX = ( aViewData.GetPPTX() != nOldX );
2368 0 : bool bChangedY = ( aViewData.GetPPTY() != nOldY );
2369 0 : if ( bChangedX || bChangedY )
2370 : {
2371 : // call view SetZoom (including draw scale, split update etc)
2372 : // and paint only if values changed
2373 :
2374 0 : Fraction aZoomX = aViewData.GetZoomX();
2375 0 : Fraction aZoomY = aViewData.GetZoomY();
2376 0 : SetZoom( aZoomX, aZoomY, false );
2377 :
2378 0 : PaintGrid();
2379 0 : if (bChangedX)
2380 0 : PaintTop();
2381 0 : if (bChangedY)
2382 0 : PaintLeft();
2383 : }
2384 0 : }
2385 :
2386 0 : void ScTabView::ActivateView( bool bActivate, bool bFirst )
2387 : {
2388 0 : if ( bActivate == aViewData.IsActive() && !bFirst )
2389 : {
2390 : // keine Assertion mehr - kommt vor, wenn vorher im Drag&Drop
2391 : // auf ein anderes Dokument umgeschaltet wurde
2392 0 : return;
2393 : }
2394 :
2395 : // wird nur bei MDI-(De)Activate gerufen
2396 : // aViewData.Activate hinten wegen Cursor-Show bei KillEditView
2397 : // Markierung nicht mehr loeschen - wenn an der ViewData Activate(false) gesetzt ist,
2398 : // wird die Markierung nicht ausgegeben
2399 :
2400 0 : if (!bActivate)
2401 : {
2402 0 : ScModule* pScMod = SC_MOD();
2403 0 : bool bRefMode = pScMod->IsFormulaMode();
2404 :
2405 : // Referenzeingabe nicht abbrechen, um Referenzen auf
2406 : // andere Dokumente zuzulassen
2407 :
2408 0 : if (!bRefMode)
2409 : {
2410 : // pass view to GetInputHdl, this view may not be current anymore
2411 0 : ScInputHandler* pHdl = SC_MOD()->GetInputHdl(aViewData.GetViewShell());
2412 0 : if (pHdl)
2413 0 : pHdl->EnterHandler();
2414 : }
2415 : }
2416 :
2417 0 : PaintExtras();
2418 :
2419 0 : aViewData.Activate(bActivate);
2420 :
2421 0 : PaintBlock(false); // Repaint, Markierung je nach Active-Status
2422 :
2423 0 : if (!bActivate)
2424 0 : HideAllCursors(); // Cursor
2425 0 : else if (!bFirst)
2426 0 : ShowAllCursors();
2427 :
2428 0 : if (bActivate)
2429 : {
2430 0 : if ( bFirst )
2431 : {
2432 0 : ScSplitPos eWin = aViewData.GetActivePart();
2433 : OSL_ENSURE( pGridWin[eWin], "rottes Dokument, nicht alle SplitPos in GridWin" );
2434 0 : if ( !pGridWin[eWin] )
2435 : {
2436 0 : eWin = SC_SPLIT_BOTTOMLEFT;
2437 0 : if ( !pGridWin[eWin] )
2438 : {
2439 : short i;
2440 0 : for ( i=0; i<4; i++ )
2441 : {
2442 0 : if ( pGridWin[i] )
2443 : {
2444 0 : eWin = (ScSplitPos) i;
2445 0 : break; // for
2446 : }
2447 : }
2448 : OSL_ENSURE( i<4, "und BUMM" );
2449 : }
2450 0 : aViewData.SetActivePart( eWin );
2451 : }
2452 : }
2453 : // hier nicht mehr selber GrabFocus rufen!
2454 : // Wenn das Doc bearbeitet wird, ruft der Sfx selber GrabFocus am Fenster der Shell.
2455 : // Wenn es z.B. ein Mailbody ist, darf es den Focus nicht bekommen (Bug #43638#)
2456 :
2457 0 : UpdateInputContext();
2458 : }
2459 : else
2460 0 : pGridWin[aViewData.GetActivePart()]->ClickExtern();
2461 : }
2462 :
2463 0 : void ScTabView::ActivatePart( ScSplitPos eWhich )
2464 : {
2465 0 : ScSplitPos eOld = aViewData.GetActivePart();
2466 0 : if ( eOld != eWhich )
2467 : {
2468 0 : bInActivatePart = true;
2469 :
2470 0 : bool bRefMode = SC_MOD()->IsFormulaMode();
2471 :
2472 : // the HasEditView call during SetCursor would fail otherwise
2473 0 : if ( aViewData.HasEditView(eOld) && !bRefMode )
2474 0 : UpdateInputLine();
2475 :
2476 0 : ScHSplitPos eOldH = WhichH(eOld);
2477 0 : ScVSplitPos eOldV = WhichV(eOld);
2478 0 : ScHSplitPos eNewH = WhichH(eWhich);
2479 0 : ScVSplitPos eNewV = WhichV(eWhich);
2480 0 : bool bTopCap = pColBar[eOldH] && pColBar[eOldH]->IsMouseCaptured();
2481 0 : bool bLeftCap = pRowBar[eOldV] && pRowBar[eOldV]->IsMouseCaptured();
2482 :
2483 0 : bool bFocus = pGridWin[eOld]->HasFocus();
2484 0 : bool bCapture = pGridWin[eOld]->IsMouseCaptured();
2485 0 : if (bCapture)
2486 0 : pGridWin[eOld]->ReleaseMouse();
2487 0 : pGridWin[eOld]->ClickExtern();
2488 0 : pGridWin[eOld]->HideCursor();
2489 0 : pGridWin[eWhich]->HideCursor();
2490 0 : aViewData.SetActivePart( eWhich );
2491 :
2492 0 : ScTabViewShell* pShell = aViewData.GetViewShell();
2493 0 : pShell->WindowChanged();
2494 :
2495 0 : pSelEngine->SetWindow(pGridWin[eWhich]);
2496 0 : pSelEngine->SetWhich(eWhich);
2497 0 : pSelEngine->SetVisibleArea( Rectangle(Point(), pGridWin[eWhich]->GetOutputSizePixel()) );
2498 :
2499 0 : pGridWin[eOld]->MoveMouseStatus(*pGridWin[eWhich]);
2500 :
2501 0 : if ( bCapture || pGridWin[eWhich]->IsMouseCaptured() )
2502 : {
2503 : // Tracking statt CaptureMouse, damit sauber abgebrochen werden kann
2504 : // (SelectionEngine ruft CaptureMouse beim SetWindow)
2505 : //! Irgendwann sollte die SelectionEngine selber StartTracking rufen!?!
2506 0 : pGridWin[eWhich]->ReleaseMouse();
2507 0 : pGridWin[eWhich]->StartTracking();
2508 : }
2509 :
2510 0 : if ( bTopCap && pColBar[eNewH] )
2511 : {
2512 0 : pColBar[eOldH]->SetIgnoreMove(true);
2513 0 : pColBar[eNewH]->SetIgnoreMove(false);
2514 0 : pHdrSelEng->SetWindow( pColBar[eNewH] );
2515 0 : long nWidth = pColBar[eNewH]->GetOutputSizePixel().Width();
2516 0 : pHdrSelEng->SetVisibleArea( Rectangle( 0, LONG_MIN, nWidth-1, LONG_MAX ) );
2517 0 : pColBar[eNewH]->CaptureMouse();
2518 : }
2519 0 : if ( bLeftCap && pRowBar[eNewV] )
2520 : {
2521 0 : pRowBar[eOldV]->SetIgnoreMove(true);
2522 0 : pRowBar[eNewV]->SetIgnoreMove(false);
2523 0 : pHdrSelEng->SetWindow( pRowBar[eNewV] );
2524 0 : long nHeight = pRowBar[eNewV]->GetOutputSizePixel().Height();
2525 0 : pHdrSelEng->SetVisibleArea( Rectangle( LONG_MIN, 0, LONG_MAX, nHeight-1 ) );
2526 0 : pRowBar[eNewV]->CaptureMouse();
2527 : }
2528 0 : aHdrFunc.SetWhich(eWhich);
2529 :
2530 0 : pGridWin[eOld]->ShowCursor();
2531 0 : pGridWin[eWhich]->ShowCursor();
2532 :
2533 0 : SfxInPlaceClient* pClient = aViewData.GetViewShell()->GetIPClient();
2534 0 : bool bOleActive = ( pClient && pClient->IsObjectInPlaceActive() );
2535 :
2536 : // don't switch ViewShell's active window during RefInput, because the focus
2537 : // might change, and subsequent SetReference calls wouldn't find the right EditView
2538 0 : if ( !bRefMode && !bOleActive )
2539 0 : aViewData.GetViewShell()->SetWindow( pGridWin[eWhich] );
2540 :
2541 0 : if ( bFocus && !aViewData.IsAnyFillMode() && !bRefMode )
2542 : {
2543 : // GrabFocus nur, wenn vorher das andere GridWindow den Focus hatte
2544 : // (z.B. wegen Suchen & Ersetzen)
2545 0 : pGridWin[eWhich]->GrabFocus();
2546 : }
2547 :
2548 0 : bInActivatePart = false;
2549 : }
2550 0 : }
2551 :
2552 0 : void ScTabView::HideListBox()
2553 : {
2554 0 : for (sal_uInt16 i=0; i<4; i++)
2555 0 : if (pGridWin[i])
2556 0 : pGridWin[i]->ClickExtern();
2557 0 : }
2558 :
2559 0 : void ScTabView::UpdateInputContext()
2560 : {
2561 0 : ScGridWindow* pWin = pGridWin[aViewData.GetActivePart()];
2562 0 : if (pWin)
2563 0 : pWin->UpdateInputContext();
2564 :
2565 0 : if (pTabControl)
2566 0 : pTabControl->UpdateInputContext();
2567 0 : }
2568 :
2569 : // GetGridWidth - Breite eines Ausgabebereichs (fuer ViewData)
2570 :
2571 0 : long ScTabView::GetGridWidth( ScHSplitPos eWhich )
2572 : {
2573 0 : ScSplitPos eGridWhich = ( eWhich == SC_SPLIT_LEFT ) ? SC_SPLIT_BOTTOMLEFT : SC_SPLIT_BOTTOMRIGHT;
2574 0 : if (pGridWin[eGridWhich])
2575 0 : return pGridWin[eGridWhich]->GetSizePixel().Width();
2576 : else
2577 0 : return 0;
2578 : }
2579 :
2580 : // GetGridHeight - Hoehe eines Ausgabebereichs (fuer ViewData)
2581 :
2582 0 : long ScTabView::GetGridHeight( ScVSplitPos eWhich )
2583 : {
2584 0 : ScSplitPos eGridWhich = ( eWhich == SC_SPLIT_TOP ) ? SC_SPLIT_TOPLEFT : SC_SPLIT_BOTTOMLEFT;
2585 0 : if (pGridWin[eGridWhich])
2586 0 : return pGridWin[eGridWhich]->GetSizePixel().Height();
2587 : else
2588 0 : return 0;
2589 : }
2590 :
2591 0 : void ScTabView::UpdateInputLine()
2592 : {
2593 0 : SC_MOD()->InputEnterHandler();
2594 0 : }
2595 :
2596 0 : void ScTabView::ZoomChanged()
2597 : {
2598 0 : ScInputHandler* pHdl = SC_MOD()->GetInputHdl(aViewData.GetViewShell());
2599 0 : if (pHdl)
2600 0 : pHdl->SetRefScale( aViewData.GetZoomX(), aViewData.GetZoomY() );
2601 :
2602 0 : UpdateFixPos();
2603 :
2604 0 : UpdateScrollBars();
2605 :
2606 : // VisArea...
2607 : // AW: Discussed with NN if there is a reason that new map mode was only set for one window,
2608 : // but is not. Setting only on one window causes the first repaint to have the old mapMode
2609 : // in three of four views, so the overlay will save the wrong content e.g. when zooming out.
2610 : // Changing to setting map mode at all windows.
2611 : sal_uInt32 a;
2612 :
2613 0 : for(a = 0L; a < 4L; a++)
2614 : {
2615 0 : if(pGridWin[a])
2616 : {
2617 0 : pGridWin[a]->SetMapMode(pGridWin[a]->GetDrawMapMode());
2618 : }
2619 : }
2620 :
2621 0 : SetNewVisArea();
2622 :
2623 0 : InterpretVisible(); // have everything calculated before painting
2624 :
2625 0 : SfxBindings& rBindings = aViewData.GetBindings();
2626 0 : rBindings.Invalidate( SID_ATTR_ZOOM );
2627 0 : rBindings.Invalidate( SID_ATTR_ZOOMSLIDER );
2628 :
2629 0 : HideNoteMarker();
2630 :
2631 : // AW: To not change too much, use pWin here
2632 0 : ScGridWindow* pWin = pGridWin[aViewData.GetActivePart()];
2633 :
2634 0 : if ( pWin && aViewData.HasEditView( aViewData.GetActivePart() ) )
2635 : {
2636 : // flush OverlayManager before changing the MapMode
2637 0 : pWin->flushOverlayManager();
2638 :
2639 : // make sure the EditView's position and size are updated
2640 : // with the right (logic, not drawing) MapMode
2641 0 : pWin->SetMapMode( aViewData.GetLogicMode() );
2642 0 : UpdateEditView();
2643 : }
2644 0 : }
2645 :
2646 0 : void ScTabView::CheckNeedsRepaint()
2647 : {
2648 : sal_uInt16 i;
2649 0 : for (i=0; i<4; i++)
2650 0 : if ( pGridWin[i] && pGridWin[i]->IsVisible() )
2651 0 : pGridWin[i]->CheckNeedsRepaint();
2652 0 : }
2653 :
2654 0 : bool ScTabView::NeedsRepaint()
2655 : {
2656 0 : for (size_t i = 0; i < 4; i++)
2657 0 : if (pGridWin[i] && pGridWin[i]->IsVisible() && pGridWin[i]->NeedsRepaint())
2658 0 : return true;
2659 0 : return false;
2660 0 : }
2661 :
2662 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
