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