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 "scitems.hxx"
21 : #include <editeng/eeitem.hxx>
22 :
23 : #include <sfx2/viewfrm.hxx>
24 : #include <editeng/adjustitem.hxx>
25 : #include <svx/algitem.hxx>
26 : #include <editeng/brushitem.hxx>
27 : #include <svtools/colorcfg.hxx>
28 : #include <editeng/editview.hxx>
29 : #include <editeng/editstat.hxx>
30 : #include <editeng/outliner.hxx>
31 : #include <editeng/unolingu.hxx>
32 : #include <editeng/justifyitem.hxx>
33 :
34 : #include <vcl/svapp.hxx>
35 : #include <rtl/math.hxx>
36 :
37 : #include <sax/tools/converter.hxx>
38 :
39 : #include "viewdata.hxx"
40 : #include "docoptio.hxx"
41 : #include "scmod.hxx"
42 : #include "global.hxx"
43 : #include "document.hxx"
44 : #include "attrib.hxx"
45 : #include "tabview.hxx"
46 : #include "tabvwsh.hxx"
47 : #include "docsh.hxx"
48 : #include "sc.hrc"
49 : #include "patattr.hxx"
50 : #include "editutil.hxx"
51 : #include "scextopt.hxx"
52 : #include "miscuno.hxx"
53 : #include "unonames.hxx"
54 : #include "inputopt.hxx"
55 : #include "viewutil.hxx"
56 : #include "markdata.hxx"
57 : #include "stlalgorithm.hxx"
58 : #include "ViewSettingsSequenceDefines.hxx"
59 : #include <gridwin.hxx>
60 : #include <rtl/ustrbuf.hxx>
61 : #include <boost/checked_delete.hpp>
62 : #include <comphelper/processfactory.hxx>
63 : #include <comphelper/string.hxx>
64 :
65 : #include <com/sun/star/container/XNameContainer.hpp>
66 : #include <com/sun/star/document/NamedPropertyValues.hpp>
67 :
68 : using namespace com::sun::star;
69 :
70 : #define SC_GROWY_SMALL_EXTRA 100
71 : #define SC_GROWY_BIG_EXTRA 200
72 :
73 : #define TAG_TABBARWIDTH "tw:"
74 :
75 : static bool bMoveArea = false; // Member?
76 : sal_uInt16 nEditAdjust = SVX_ADJUST_LEFT; // Member!
77 :
78 523 : ScViewDataTable::ScViewDataTable() :
79 : eZoomType( SvxZoomType::PERCENT ),
80 : aZoomX( 1,1 ),
81 : aZoomY( 1,1 ),
82 : aPageZoomX( 3,5 ), // Page-Default: 60%
83 : aPageZoomY( 3,5 ),
84 : nHSplitPos( 0 ),
85 : nVSplitPos( 0 ),
86 : eHSplitMode( SC_SPLIT_NONE ),
87 : eVSplitMode( SC_SPLIT_NONE ),
88 : eWhichActive( SC_SPLIT_BOTTOMLEFT ),
89 : nFixPosX( 0 ),
90 : nFixPosY( 0 ),
91 : nCurX( 0 ),
92 : nCurY( 0 ),
93 : nOldCurX( 0 ),
94 : nOldCurY( 0 ),
95 : bShowGrid( true ),
96 523 : mbOldCursorValid( false )
97 : {
98 523 : nPosX[0]=nPosX[1]=0;
99 523 : nPosY[0]=nPosY[1]=0;
100 523 : nTPosX[0]=nTPosX[1]=0;
101 523 : nTPosY[0]=nTPosY[1]=0;
102 523 : nMPosX[0]=nMPosX[1]=0;
103 523 : nMPosY[0]=nMPosY[1]=0;
104 523 : nPixPosX[0]=nPixPosX[1]=0;
105 523 : nPixPosY[0]=nPixPosY[1]=0;
106 523 : }
107 :
108 517 : ScViewDataTable::~ScViewDataTable()
109 : {
110 517 : }
111 :
112 292 : void ScViewDataTable::WriteUserDataSequence(uno::Sequence <beans::PropertyValue>& rSettings, const ScViewData& /*rViewData*/, SCTAB /*nTab*/) const
113 : {
114 292 : rSettings.realloc(SC_TABLE_VIEWSETTINGS_COUNT);
115 292 : beans::PropertyValue* pSettings = rSettings.getArray();
116 292 : if (pSettings)
117 : {
118 292 : pSettings[SC_CURSOR_X].Name = SC_CURSORPOSITIONX;
119 292 : pSettings[SC_CURSOR_X].Value <<= sal_Int32(nCurX);
120 292 : pSettings[SC_CURSOR_Y].Name = SC_CURSORPOSITIONY;
121 292 : pSettings[SC_CURSOR_Y].Value <<= sal_Int32(nCurY);
122 292 : pSettings[SC_HORIZONTAL_SPLIT_MODE].Name = SC_HORIZONTALSPLITMODE;
123 292 : pSettings[SC_HORIZONTAL_SPLIT_MODE].Value <<= sal_Int16(eHSplitMode);
124 292 : pSettings[SC_VERTICAL_SPLIT_MODE].Name = SC_VERTICALSPLITMODE;
125 292 : pSettings[SC_VERTICAL_SPLIT_MODE].Value <<= sal_Int16(eVSplitMode);
126 292 : pSettings[SC_HORIZONTAL_SPLIT_POSITION].Name = SC_HORIZONTALSPLITPOSITION;
127 292 : if (eHSplitMode == SC_SPLIT_FIX)
128 0 : pSettings[SC_HORIZONTAL_SPLIT_POSITION].Value <<= sal_Int32(nFixPosX);
129 : else
130 292 : pSettings[SC_HORIZONTAL_SPLIT_POSITION].Value <<= sal_Int32(nHSplitPos);
131 292 : pSettings[SC_VERTICAL_SPLIT_POSITION].Name = SC_VERTICALSPLITPOSITION;
132 292 : if (eVSplitMode == SC_SPLIT_FIX)
133 0 : pSettings[SC_VERTICAL_SPLIT_POSITION].Value <<= sal_Int32(nFixPosY);
134 : else
135 292 : pSettings[SC_VERTICAL_SPLIT_POSITION].Value <<= sal_Int32(nVSplitPos);
136 292 : pSettings[SC_ACTIVE_SPLIT_RANGE].Name = SC_ACTIVESPLITRANGE;
137 292 : pSettings[SC_ACTIVE_SPLIT_RANGE].Value <<= sal_Int16(eWhichActive);
138 292 : pSettings[SC_POSITION_LEFT].Name = SC_POSITIONLEFT;
139 292 : pSettings[SC_POSITION_LEFT].Value <<= sal_Int32(nPosX[SC_SPLIT_LEFT]);
140 292 : pSettings[SC_POSITION_RIGHT].Name = SC_POSITIONRIGHT;
141 292 : pSettings[SC_POSITION_RIGHT].Value <<= sal_Int32(nPosX[SC_SPLIT_RIGHT]);
142 292 : pSettings[SC_POSITION_TOP].Name = SC_POSITIONTOP;
143 292 : pSettings[SC_POSITION_TOP].Value <<= sal_Int32(nPosY[SC_SPLIT_TOP]);
144 292 : pSettings[SC_POSITION_BOTTOM].Name = SC_POSITIONBOTTOM;
145 292 : pSettings[SC_POSITION_BOTTOM].Value <<= sal_Int32(nPosY[SC_SPLIT_BOTTOM]);
146 :
147 292 : sal_Int32 nZoomValue ((aZoomY.GetNumerator() * 100) / aZoomY.GetDenominator());
148 292 : sal_Int32 nPageZoomValue ((aPageZoomY.GetNumerator() * 100) / aPageZoomY.GetDenominator());
149 292 : pSettings[SC_TABLE_ZOOM_TYPE].Name = SC_ZOOMTYPE;
150 292 : pSettings[SC_TABLE_ZOOM_TYPE].Value <<= sal_Int16(eZoomType);
151 292 : pSettings[SC_TABLE_ZOOM_VALUE].Name = SC_ZOOMVALUE;
152 292 : pSettings[SC_TABLE_ZOOM_VALUE].Value <<= nZoomValue;
153 292 : pSettings[SC_TABLE_PAGE_VIEW_ZOOM_VALUE].Name = SC_PAGEVIEWZOOMVALUE;
154 292 : pSettings[SC_TABLE_PAGE_VIEW_ZOOM_VALUE].Value <<= nPageZoomValue;
155 :
156 292 : pSettings[SC_TABLE_SHOWGRID].Name = SC_UNO_SHOWGRID;
157 292 : pSettings[SC_TABLE_SHOWGRID].Value <<= bShowGrid;
158 : }
159 292 : }
160 :
161 471 : void ScViewDataTable::ReadUserDataSequence(const uno::Sequence <beans::PropertyValue>& aSettings, ScViewData& rViewData, SCTAB nTab, bool& rHasZoom )
162 : {
163 471 : rHasZoom = false;
164 :
165 471 : sal_Int32 nCount(aSettings.getLength());
166 471 : sal_Int32 nTemp32(0);
167 471 : sal_Int16 nTemp16(0);
168 471 : sal_Int32 nTempPosV(0);
169 471 : sal_Int32 nTempPosH(0);
170 471 : sal_Int32 nTempPosVTw(0);
171 471 : sal_Int32 nTempPosHTw(0);
172 471 : bool bHasVSplitInTwips = false;
173 471 : bool bHasHSplitInTwips = false;
174 8557 : for (sal_Int32 i = 0; i < nCount; i++)
175 : {
176 8086 : OUString sName(aSettings[i].Name);
177 8086 : if (sName == SC_CURSORPOSITIONX)
178 : {
179 471 : aSettings[i].Value >>= nTemp32;
180 471 : nCurX = SanitizeCol( static_cast<SCCOL>(nTemp32));
181 : }
182 7615 : else if (sName == SC_CURSORPOSITIONY)
183 : {
184 471 : aSettings[i].Value >>= nTemp32;
185 471 : nCurY = SanitizeRow( static_cast<SCROW>(nTemp32));
186 : }
187 7144 : else if (sName == SC_HORIZONTALSPLITMODE)
188 : {
189 471 : aSettings[i].Value >>= nTemp16;
190 471 : eHSplitMode = static_cast<ScSplitMode>(nTemp16);
191 : }
192 6673 : else if (sName == SC_VERTICALSPLITMODE)
193 : {
194 471 : aSettings[i].Value >>= nTemp16;
195 471 : eVSplitMode = static_cast<ScSplitMode>(nTemp16);
196 : }
197 6202 : else if (sName == SC_HORIZONTALSPLITPOSITION)
198 : {
199 364 : aSettings[i].Value >>= nTempPosH;
200 364 : bHasHSplitInTwips = false;
201 : }
202 5838 : else if (sName == SC_VERTICALSPLITPOSITION)
203 : {
204 364 : aSettings[i].Value >>= nTempPosV;
205 364 : bHasVSplitInTwips = false;
206 : }
207 5474 : else if (sName == SC_HORIZONTALSPLITPOSITION_TWIPS)
208 : {
209 107 : aSettings[i].Value >>= nTempPosHTw;
210 107 : bHasHSplitInTwips = true;
211 : }
212 5367 : else if (sName == SC_VERTICALSPLITPOSITION_TWIPS)
213 : {
214 107 : aSettings[i].Value >>= nTempPosVTw;
215 107 : bHasVSplitInTwips = true;
216 : }
217 5260 : else if (sName == SC_ACTIVESPLITRANGE)
218 : {
219 471 : aSettings[i].Value >>= nTemp16;
220 471 : eWhichActive = static_cast<ScSplitPos>(nTemp16);
221 : }
222 4789 : else if (sName == SC_POSITIONLEFT)
223 : {
224 471 : aSettings[i].Value >>= nTemp32;
225 471 : nPosX[SC_SPLIT_LEFT] = SanitizeCol( static_cast<SCCOL>(nTemp32));
226 : }
227 4318 : else if (sName == SC_POSITIONRIGHT)
228 : {
229 471 : aSettings[i].Value >>= nTemp32;
230 471 : nPosX[SC_SPLIT_RIGHT] = SanitizeCol( static_cast<SCCOL>(nTemp32));
231 : }
232 3847 : else if (sName == SC_POSITIONTOP)
233 : {
234 471 : aSettings[i].Value >>= nTemp32;
235 471 : nPosY[SC_SPLIT_TOP] = SanitizeRow( static_cast<SCROW>(nTemp32));
236 : }
237 3376 : else if (sName == SC_POSITIONBOTTOM)
238 : {
239 471 : aSettings[i].Value >>= nTemp32;
240 471 : nPosY[SC_SPLIT_BOTTOM] = SanitizeRow( static_cast<SCROW>(nTemp32));
241 : }
242 2905 : else if (sName == SC_ZOOMTYPE)
243 : {
244 471 : aSettings[i].Value >>= nTemp16;
245 471 : eZoomType = SvxZoomType(nTemp16);
246 471 : rHasZoom = true; // set if there is any zoom information
247 : }
248 2434 : else if (sName == SC_ZOOMVALUE)
249 : {
250 471 : aSettings[i].Value >>= nTemp32;
251 471 : Fraction aZoom(nTemp32, 100);
252 471 : aZoomX = aZoomY = aZoom;
253 471 : rHasZoom = true;
254 : }
255 1963 : else if (sName == SC_PAGEVIEWZOOMVALUE)
256 : {
257 471 : aSettings[i].Value >>= nTemp32;
258 471 : Fraction aZoom(nTemp32, 100);
259 471 : aPageZoomX = aPageZoomY = aZoom;
260 471 : rHasZoom = true;
261 : }
262 1492 : else if (sName == SC_UNO_SHOWGRID)
263 : {
264 471 : aSettings[i].Value >>= bShowGrid;
265 : }
266 1021 : else if (sName == SC_TABLESELECTED)
267 : {
268 107 : bool bSelected = false;
269 107 : aSettings[i].Value >>= bSelected;
270 107 : rViewData.GetMarkData().SelectTable( nTab, bSelected );
271 : }
272 914 : else if (sName == SC_UNONAME_TABCOLOR)
273 : {
274 : // There are documents out there that have their tab color defined as a view setting.
275 0 : sal_Int32 nColor = COL_AUTO;
276 0 : aSettings[i].Value >>= nColor;
277 0 : if (static_cast<ColorData>(nColor) != COL_AUTO)
278 : {
279 0 : ScDocument* pDoc = rViewData.GetDocument();
280 0 : pDoc->SetTabBgColor(nTab, Color(static_cast<ColorData>(nColor)));
281 : }
282 : }
283 8086 : }
284 471 : if (eHSplitMode == SC_SPLIT_FIX)
285 0 : nFixPosX = SanitizeCol( static_cast<SCCOL>( bHasHSplitInTwips ? nTempPosHTw : nTempPosH ));
286 : else
287 471 : nHSplitPos = bHasHSplitInTwips ? static_cast< long >( nTempPosHTw * rViewData.GetPPTX() ) : nTempPosH;
288 :
289 471 : if (eVSplitMode == SC_SPLIT_FIX)
290 0 : nFixPosY = SanitizeRow( static_cast<SCROW>( bHasVSplitInTwips ? nTempPosVTw : nTempPosV ));
291 : else
292 471 : nVSplitPos = bHasVSplitInTwips ? static_cast< long >( nTempPosVTw * rViewData.GetPPTY() ) : nTempPosV;
293 471 : }
294 :
295 353 : ScViewData::ScViewData( ScDocShell* pDocSh, ScTabViewShell* pViewSh ) :
296 353 : mpMarkData(new ScMarkData),
297 : pDocShell ( pDocSh ),
298 : pDoc ( NULL ),
299 : pView ( pViewSh ),
300 : pViewShell ( pViewSh ),
301 353 : pOptions ( new ScViewOptions ),
302 : pSpellingView ( NULL ),
303 : aLogicMode ( MAP_100TH_MM ),
304 : eDefZoomType( SvxZoomType::PERCENT ),
305 : aDefZoomX ( 1,1 ),
306 : aDefZoomY ( 1,1 ),
307 : aDefPageZoomX( 3,5 ),
308 : aDefPageZoomY( 3,5 ),
309 : eRefType ( SC_REFTYPE_NONE ),
310 : nTabNo ( 0 ),
311 : nRefTabNo ( 0 ),
312 : nRefStartX(0),
313 : nRefStartY(0),
314 : nRefStartZ(0),
315 : nRefEndX(0),
316 : nRefEndY(0),
317 : nRefEndZ(0),
318 : nFillStartX(0),
319 : nFillStartY(0),
320 : nFillEndX(0),
321 : nFillEndY(0),
322 : nPasteFlags ( SC_PASTE_NONE ),
323 : eEditActivePart( SC_SPLIT_BOTTOMLEFT ),
324 : nFillMode ( SC_FILL_NONE ),
325 : bActive ( true ), // how to initialize?
326 : bIsRefMode ( false ),
327 : bDelMarkValid( false ),
328 : bPagebreak ( false ),
329 1059 : bSelCtrlMouseClick( false )
330 : {
331 353 : mpMarkData->SelectOneTable(0); // Sync with nTabNo
332 :
333 353 : SetGridMode ( true );
334 353 : SetSyntaxMode ( false );
335 353 : SetHeaderMode ( true );
336 353 : SetTabMode ( true );
337 353 : SetVScrollMode ( true );
338 353 : SetHScrollMode ( true );
339 353 : SetOutlineMode ( true );
340 :
341 : aScrSize = Size( (long) ( STD_COL_WIDTH * PIXEL_PER_TWIPS * OLE_STD_CELLS_X ),
342 353 : (long) ( ScGlobal::nStdRowHeight * PIXEL_PER_TWIPS * OLE_STD_CELLS_Y ) );
343 353 : maTabData.push_back( new ScViewDataTable );
344 353 : pThisTab = maTabData[nTabNo];
345 1765 : for (sal_uInt16 j=0; j<4; j++)
346 : {
347 1412 : pEditView[j] = NULL;
348 1412 : bEditActive[j] = false;
349 : }
350 :
351 353 : nEditEndCol = nEditStartCol = nEditCol = 0;
352 353 : nEditEndRow = nEditRow = 0;
353 353 : nTabStartCol = SC_TABSTART_NONE;
354 :
355 353 : if (pDocShell)
356 : {
357 353 : pDoc = &pDocShell->GetDocument();
358 353 : *pOptions = pDoc->GetViewOptions();
359 : }
360 :
361 : // don't show hidden tables
362 353 : if (pDoc && !pDoc->IsVisible(nTabNo))
363 : {
364 0 : while ( !pDoc->IsVisible(nTabNo) && pDoc->HasTable(nTabNo+1) )
365 : {
366 0 : ++nTabNo;
367 0 : maTabData.push_back(NULL);
368 : }
369 0 : maTabData[nTabNo] = new ScViewDataTable() ;
370 0 : pThisTab = maTabData[nTabNo];
371 : }
372 :
373 353 : CalcPPT();
374 353 : }
375 :
376 0 : ScViewData::ScViewData( const ScViewData& rViewData ) :
377 : maTabData( rViewData.maTabData ),
378 0 : mpMarkData(new ScMarkData(*rViewData.mpMarkData)),
379 : pDocShell ( rViewData.pDocShell ),
380 : pDoc ( rViewData.pDoc ),
381 : pView ( rViewData.pView ),
382 : pViewShell ( rViewData.pViewShell ),
383 0 : pOptions ( new ScViewOptions( *(rViewData.pOptions) ) ),
384 : pSpellingView ( rViewData.pSpellingView ),
385 : aLogicMode ( rViewData.aLogicMode ),
386 : eDefZoomType( rViewData.eDefZoomType ),
387 : aDefZoomX ( rViewData.aDefZoomX ),
388 : aDefZoomY ( rViewData.aDefZoomY ),
389 : aDefPageZoomX( rViewData.aDefPageZoomX ),
390 : aDefPageZoomY( rViewData.aDefPageZoomY ),
391 : eRefType ( SC_REFTYPE_NONE ),
392 : nTabNo ( rViewData.nTabNo ),
393 : nRefTabNo ( rViewData.nTabNo ), // no RefMode
394 : nRefStartX(0),
395 : nRefStartY(0),
396 : nRefStartZ(0),
397 : nRefEndX(0),
398 : nRefEndY(0),
399 : nRefEndZ(0),
400 : nFillStartX(0),
401 : nFillStartY(0),
402 : nFillEndX(0),
403 : nFillEndY(0),
404 : nPasteFlags ( SC_PASTE_NONE ),
405 : eEditActivePart( rViewData.eEditActivePart ),
406 : nFillMode ( SC_FILL_NONE ),
407 : bActive ( true ), // how to initialize?
408 : bIsRefMode ( false ),
409 : bDelMarkValid( false ),
410 : bPagebreak ( rViewData.bPagebreak ),
411 0 : bSelCtrlMouseClick( rViewData.bSelCtrlMouseClick )
412 : {
413 :
414 0 : SetGridMode ( rViewData.IsGridMode() );
415 0 : SetSyntaxMode ( rViewData.IsSyntaxMode() );
416 0 : SetHeaderMode ( rViewData.IsHeaderMode() );
417 0 : SetTabMode ( rViewData.IsTabMode() );
418 0 : SetVScrollMode ( rViewData.IsVScrollMode() );
419 0 : SetHScrollMode ( rViewData.IsHScrollMode() );
420 0 : SetOutlineMode ( rViewData.IsOutlineMode() );
421 :
422 0 : aScrSize = rViewData.aScrSize;
423 :
424 0 : pThisTab = maTabData[nTabNo];
425 0 : for (sal_uInt16 j=0; j<4; j++)
426 : {
427 0 : pEditView[j] = NULL;
428 0 : bEditActive[j] = false;
429 : }
430 :
431 0 : nEditEndCol = nEditStartCol = nEditCol = 0;
432 0 : nEditEndRow = nEditRow = 0;
433 0 : nTabStartCol = SC_TABSTART_NONE;
434 0 : CalcPPT();
435 0 : }
436 :
437 0 : void ScViewData::InitData( ScDocument* pDocument )
438 : {
439 0 : pDoc = pDocument;
440 0 : *pOptions = pDoc->GetViewOptions();
441 0 : }
442 :
443 276954 : ScDocument* ScViewData::GetDocument() const
444 : {
445 276954 : if (pDoc)
446 276954 : return pDoc;
447 0 : else if (pDocShell)
448 0 : return &pDocShell->GetDocument();
449 :
450 : OSL_FAIL("kein Document an ViewData");
451 0 : return NULL;
452 : }
453 :
454 700 : ScViewData::~ScViewData()
455 : {
456 350 : KillEditView();
457 350 : delete pOptions;
458 : ::std::for_each(
459 350 : maTabData.begin(), maTabData.end(), boost::checked_deleter<ScViewDataTable>());
460 350 : }
461 :
462 64 : void ScViewData::UpdateCurrentTab()
463 : {
464 64 : pThisTab = maTabData[nTabNo];
465 128 : while (!pThisTab)
466 : {
467 0 : if (nTabNo > 0)
468 0 : pThisTab = maTabData[--nTabNo];
469 : else
470 0 : pThisTab = maTabData[0] = new ScViewDataTable;
471 : }
472 64 : }
473 :
474 46 : void ScViewData::InsertTab( SCTAB nTab )
475 : {
476 46 : if( nTab >= static_cast<SCTAB>(maTabData.size()))
477 0 : maTabData.resize(nTab+1, NULL);
478 : else
479 46 : maTabData.insert( maTabData.begin() + nTab, nullptr );
480 46 : CreateTabData( nTab );
481 :
482 46 : UpdateCurrentTab();
483 46 : mpMarkData->InsertTab( nTab );
484 46 : }
485 :
486 0 : void ScViewData::InsertTabs( SCTAB nTab, SCTAB nNewSheets )
487 : {
488 0 : if( nTab+nNewSheets >= static_cast<SCTAB>(maTabData.size()))
489 0 : maTabData.resize(nTab+nNewSheets, NULL);
490 : else
491 : {
492 0 : maTabData.insert( maTabData.begin() + nTab, nNewSheets, NULL );
493 : }
494 0 : for (SCTAB i = nTab; i < nTab + nNewSheets; ++i)
495 : {
496 0 : CreateTabData( i );
497 0 : mpMarkData->InsertTab( i );
498 : }
499 0 : UpdateCurrentTab();
500 0 : }
501 :
502 18 : void ScViewData::DeleteTab( SCTAB nTab )
503 : {
504 18 : delete maTabData.at(nTab);
505 :
506 18 : maTabData.erase(maTabData.begin() + nTab);
507 18 : UpdateCurrentTab();
508 18 : mpMarkData->DeleteTab( nTab );
509 18 : }
510 :
511 0 : void ScViewData::DeleteTabs( SCTAB nTab, SCTAB nSheets )
512 : {
513 0 : for (SCTAB i = 0; i < nSheets; ++i)
514 : {
515 0 : mpMarkData->DeleteTab( nTab + i );
516 0 : delete maTabData.at(nTab + i);
517 : }
518 :
519 0 : maTabData.erase(maTabData.begin() + nTab, maTabData.begin()+ nTab+nSheets);
520 0 : UpdateCurrentTab();
521 0 : }
522 :
523 0 : void ScViewData::CopyTab( SCTAB nSrcTab, SCTAB nDestTab )
524 : {
525 0 : if (nDestTab==SC_TAB_APPEND)
526 0 : nDestTab = pDoc->GetTableCount() - 1; // something had to have been copied
527 :
528 0 : if (nDestTab > MAXTAB)
529 : {
530 : OSL_FAIL("Zuviele Tabellen");
531 0 : return;
532 : }
533 :
534 0 : if (nSrcTab >= static_cast<SCTAB>(maTabData.size()))
535 : OSL_FAIL("pTabData out of bounds, FIX IT");
536 :
537 0 : EnsureTabDataSize(nDestTab + 1);
538 :
539 0 : if ( maTabData[nSrcTab] )
540 0 : maTabData.insert(maTabData.begin() + nDestTab, new ScViewDataTable( *maTabData[nSrcTab] ));
541 : else
542 0 : maTabData.insert(maTabData.begin() + nDestTab, nullptr);
543 :
544 0 : UpdateCurrentTab();
545 0 : mpMarkData->InsertTab( nDestTab );
546 : }
547 :
548 0 : void ScViewData::MoveTab( SCTAB nSrcTab, SCTAB nDestTab )
549 : {
550 0 : if (nDestTab==SC_TAB_APPEND)
551 0 : nDestTab = pDoc->GetTableCount() - 1;
552 0 : ScViewDataTable* pTab = NULL;
553 0 : if (nSrcTab < static_cast<SCTAB>(maTabData.size()))
554 : {
555 0 : pTab = maTabData[nSrcTab];
556 0 : maTabData.erase( maTabData.begin() + nSrcTab );
557 : }
558 :
559 0 : if (nDestTab < static_cast<SCTAB>(maTabData.size()))
560 0 : maTabData.insert( maTabData.begin() + nDestTab, pTab );
561 : else
562 : {
563 0 : EnsureTabDataSize(nDestTab + 1);
564 0 : maTabData[nDestTab] = pTab;
565 : }
566 :
567 0 : UpdateCurrentTab();
568 0 : mpMarkData->DeleteTab( nSrcTab );
569 0 : mpMarkData->InsertTab( nDestTab ); // adapted if needed
570 0 : }
571 :
572 2 : void ScViewData::CreateTabData( std::vector< SCTAB >& rvTabs )
573 : {
574 2 : std::vector< SCTAB >::iterator it_end = rvTabs.end();
575 4 : for ( std::vector< SCTAB >::iterator it = rvTabs.begin(); it != it_end; ++it )
576 2 : CreateTabData(*it);
577 2 : }
578 :
579 348 : void ScViewData::SetZoomType( SvxZoomType eNew, std::vector< SCTAB >& tabs )
580 : {
581 348 : bool bAll = ( tabs.empty() );
582 :
583 348 : if ( !bAll ) // create associated table data
584 0 : CreateTabData( tabs );
585 :
586 348 : if ( bAll )
587 : {
588 696 : for ( SCTAB i = 0; i < static_cast<SCTAB>(maTabData.size()); ++i )
589 : {
590 348 : if ( maTabData[i] )
591 348 : maTabData[i]->eZoomType = eNew;
592 : }
593 348 : eDefZoomType = eNew;
594 : }
595 : else
596 : {
597 0 : std::vector< SCTAB >::iterator it_end = tabs.end();
598 0 : std::vector< SCTAB >::iterator it = tabs.begin();
599 0 : for ( ; it != it_end; ++it )
600 : {
601 0 : SCTAB i = *it;
602 0 : if ( i < static_cast<SCTAB>(maTabData.size()) && maTabData[i] )
603 0 : maTabData[i]->eZoomType = eNew;
604 : }
605 : }
606 348 : }
607 :
608 348 : void ScViewData::SetZoomType( SvxZoomType eNew, bool bAll )
609 : {
610 348 : std::vector< SCTAB > vTabs; // Empty for all tabs
611 348 : if ( !bAll ) // get selected tabs
612 : {
613 0 : ScMarkData::iterator itr = mpMarkData->begin(), itrEnd = mpMarkData->end();
614 0 : vTabs.insert(vTabs.begin(), itr, itrEnd);
615 : }
616 348 : SetZoomType( eNew, vTabs );
617 348 : }
618 :
619 350 : void ScViewData::SetZoom( const Fraction& rNewX, const Fraction& rNewY, std::vector< SCTAB >& tabs )
620 : {
621 350 : bool bAll = ( tabs.empty() );
622 350 : if ( !bAll ) // create associated table data
623 2 : CreateTabData( tabs );
624 :
625 : // sanity check - we shouldn't need something this low / big
626 : assert(rNewX > Fraction(1, 100) && rNewX < Fraction(100, 1));
627 : assert(rNewY > Fraction(1, 100) && rNewY < Fraction(100, 1));
628 :
629 350 : if ( bAll )
630 : {
631 696 : for ( SCTAB i = 0; i < static_cast<SCTAB>(maTabData.size()); ++i )
632 : {
633 348 : if ( maTabData[i] )
634 : {
635 348 : if ( bPagebreak )
636 : {
637 0 : maTabData[i]->aPageZoomX = rNewX;
638 0 : maTabData[i]->aPageZoomY = rNewY;
639 : }
640 : else
641 : {
642 348 : maTabData[i]->aZoomX = rNewX;
643 348 : maTabData[i]->aZoomY = rNewY;
644 : }
645 : }
646 : }
647 348 : if ( bPagebreak )
648 : {
649 0 : aDefPageZoomX = rNewX;
650 0 : aDefPageZoomY = rNewY;
651 : }
652 : else
653 : {
654 348 : aDefZoomX = rNewX;
655 348 : aDefZoomY = rNewY;
656 : }
657 : }
658 : else
659 : {
660 2 : std::vector< SCTAB >::iterator it_end = tabs.end();
661 2 : std::vector< SCTAB >::iterator it = tabs.begin();
662 4 : for ( ; it != it_end; ++it )
663 : {
664 2 : SCTAB i = *it;
665 2 : if ( i < static_cast<SCTAB>(maTabData.size()) && maTabData[i] )
666 : {
667 2 : if ( bPagebreak )
668 : {
669 0 : maTabData[i]->aPageZoomX = rNewX;
670 0 : maTabData[i]->aPageZoomY = rNewY;
671 : }
672 : else
673 : {
674 2 : maTabData[i]->aZoomX = rNewX;
675 2 : maTabData[i]->aZoomY = rNewY;
676 : }
677 : }
678 : }
679 : }
680 350 : RefreshZoom();
681 350 : }
682 :
683 348 : void ScViewData::SetZoom( const Fraction& rNewX, const Fraction& rNewY, bool bAll )
684 : {
685 348 : std::vector< SCTAB > vTabs;
686 348 : if ( !bAll ) // get selected tabs
687 : {
688 0 : ScMarkData::iterator itr = mpMarkData->begin(), itrEnd = mpMarkData->end();
689 0 : vTabs.insert(vTabs.begin(), itr, itrEnd);
690 : }
691 348 : SetZoom( rNewX, rNewY, vTabs );
692 348 : }
693 :
694 0 : void ScViewData::SetShowGrid( bool bShow )
695 : {
696 0 : CreateSelectedTabData();
697 0 : maTabData[nTabNo]->bShowGrid = bShow;
698 0 : }
699 :
700 1354 : void ScViewData::RefreshZoom()
701 : {
702 : // recalculate zoom-dependent values (only for current sheet)
703 :
704 1354 : CalcPPT();
705 1354 : RecalcPixPos();
706 1354 : aScenButSize = Size(0,0);
707 1354 : aLogicMode.SetScaleX( GetZoomX() );
708 1354 : aLogicMode.SetScaleY( GetZoomY() );
709 1354 : }
710 :
711 378 : void ScViewData::SetPagebreakMode( bool bSet )
712 : {
713 378 : bPagebreak = bSet;
714 :
715 378 : RefreshZoom();
716 378 : }
717 :
718 12412 : ScMarkType ScViewData::GetSimpleArea( ScRange & rRange, ScMarkData & rNewMark ) const
719 : {
720 12412 : ScMarkType eMarkType = SC_MARK_NONE;
721 :
722 12412 : if ( rNewMark.IsMarked() || rNewMark.IsMultiMarked() )
723 : {
724 2057 : if ( rNewMark.IsMultiMarked() )
725 23 : rNewMark.MarkToSimple();
726 :
727 2057 : if ( rNewMark.IsMarked() && !rNewMark.IsMultiMarked() )
728 : {
729 2034 : rNewMark.GetMarkArea( rRange );
730 2034 : if (ScViewUtil::HasFiltered( rRange, GetDocument()))
731 0 : eMarkType = SC_MARK_SIMPLE_FILTERED;
732 : else
733 2034 : eMarkType = SC_MARK_SIMPLE;
734 : }
735 : else
736 23 : eMarkType = SC_MARK_MULTI;
737 : }
738 12412 : if (eMarkType != SC_MARK_SIMPLE && eMarkType != SC_MARK_SIMPLE_FILTERED)
739 : {
740 10378 : if (eMarkType == SC_MARK_NONE)
741 10355 : eMarkType = SC_MARK_SIMPLE;
742 10378 : rRange = ScRange( GetCurX(), GetCurY(), GetTabNo() );
743 : }
744 12412 : return eMarkType;
745 : }
746 :
747 4022 : ScMarkType ScViewData::GetSimpleArea( SCCOL& rStartCol, SCROW& rStartRow, SCTAB& rStartTab,
748 : SCCOL& rEndCol, SCROW& rEndRow, SCTAB& rEndTab ) const
749 : {
750 : // parameter bMergeMark is no longer needed: The view's selection is never modified
751 : // (a local copy is used), and a multi selection that adds to a single range can always
752 : // be treated like a single selection (GetSimpleArea isn't used in selection
753 : // handling itself)
754 :
755 4022 : ScRange aRange;
756 4022 : ScMarkData aNewMark(*mpMarkData); // use a local copy for MarkToSimple
757 4022 : ScMarkType eMarkType = GetSimpleArea( aRange, aNewMark);
758 4022 : aRange.GetVars( rStartCol, rStartRow, rStartTab, rEndCol, rEndRow, rEndTab);
759 4022 : return eMarkType;
760 : }
761 :
762 8373 : ScMarkType ScViewData::GetSimpleArea( ScRange& rRange ) const
763 : {
764 : // parameter bMergeMark is no longer needed, see above
765 :
766 8373 : ScMarkData aNewMark(*mpMarkData); // use a local copy for MarkToSimple
767 8373 : return GetSimpleArea( rRange, aNewMark);
768 : }
769 :
770 10 : void ScViewData::GetMultiArea( ScRangeListRef& rRange ) const
771 : {
772 : // parameter bMergeMark is no longer needed, see GetSimpleArea
773 :
774 10 : ScMarkData aNewMark(*mpMarkData); // use a local copy for MarkToSimple
775 :
776 10 : bool bMulti = aNewMark.IsMultiMarked();
777 10 : if (bMulti)
778 : {
779 10 : aNewMark.MarkToSimple();
780 10 : bMulti = aNewMark.IsMultiMarked();
781 : }
782 10 : if (bMulti)
783 : {
784 10 : rRange = new ScRangeList;
785 10 : aNewMark.FillRangeListWithMarks( rRange, false );
786 : }
787 : else
788 : {
789 0 : ScRange aSimple;
790 0 : GetSimpleArea(aSimple);
791 0 : rRange = new ScRangeList;
792 0 : rRange->Append(aSimple);
793 10 : }
794 10 : }
795 :
796 498 : bool ScViewData::SimpleColMarked()
797 : {
798 : SCCOL nStartCol;
799 : SCROW nStartRow;
800 : SCTAB nStartTab;
801 : SCCOL nEndCol;
802 : SCROW nEndRow;
803 : SCTAB nEndTab;
804 498 : if (GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE)
805 498 : if (nStartRow==0 && nEndRow==MAXROW)
806 0 : return true;
807 :
808 498 : return false;
809 : }
810 :
811 498 : bool ScViewData::SimpleRowMarked()
812 : {
813 : SCCOL nStartCol;
814 : SCROW nStartRow;
815 : SCTAB nStartTab;
816 : SCCOL nEndCol;
817 : SCROW nEndRow;
818 : SCTAB nEndTab;
819 498 : if (GetSimpleArea(nStartCol,nStartRow,nStartTab,nEndCol,nEndRow,nEndTab) == SC_MARK_SIMPLE)
820 498 : if (nStartCol==0 && nEndCol==MAXCOL)
821 0 : return true;
822 :
823 498 : return false;
824 : }
825 :
826 996 : bool ScViewData::IsMultiMarked()
827 : {
828 : // Test for "real" multi selection, calling MarkToSimple on a local copy,
829 : // and taking filtered in simple area marks into account.
830 :
831 996 : ScRange aDummy;
832 996 : ScMarkType eType = GetSimpleArea(aDummy);
833 996 : return (eType & SC_MARK_SIMPLE) != SC_MARK_SIMPLE;
834 : }
835 :
836 0 : void ScViewData::SetFillMode( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow )
837 : {
838 0 : nFillMode = SC_FILL_FILL;
839 0 : nFillStartX = nStartCol;
840 0 : nFillStartY = nStartRow;
841 0 : nFillEndX = nEndCol;
842 0 : nFillEndY = nEndRow;
843 0 : }
844 :
845 0 : void ScViewData::SetDragMode( SCCOL nStartCol, SCROW nStartRow, SCCOL nEndCol, SCROW nEndRow,
846 : sal_uInt8 nMode )
847 : {
848 0 : nFillMode = nMode;
849 0 : nFillStartX = nStartCol;
850 0 : nFillStartY = nStartRow;
851 0 : nFillEndX = nEndCol;
852 0 : nFillEndY = nEndRow;
853 0 : }
854 :
855 0 : void ScViewData::ResetFillMode()
856 : {
857 0 : nFillMode = SC_FILL_NONE;
858 0 : }
859 :
860 0 : void ScViewData::GetFillData( SCCOL& rStartCol, SCROW& rStartRow,
861 : SCCOL& rEndCol, SCROW& rEndRow )
862 : {
863 0 : rStartCol = nFillStartX;
864 0 : rStartRow = nFillStartY;
865 0 : rEndCol = nFillEndX;
866 0 : rEndRow = nFillEndY;
867 0 : }
868 :
869 49 : SCCOL ScViewData::GetOldCurX() const
870 : {
871 49 : if (pThisTab->mbOldCursorValid)
872 0 : return pThisTab->nOldCurX;
873 : else
874 49 : return pThisTab->nCurX;
875 : }
876 :
877 50 : SCROW ScViewData::GetOldCurY() const
878 : {
879 50 : if (pThisTab->mbOldCursorValid)
880 0 : return pThisTab->nOldCurY;
881 : else
882 50 : return pThisTab->nCurY;
883 : }
884 :
885 0 : void ScViewData::SetOldCursor( SCCOL nNewX, SCROW nNewY )
886 : {
887 0 : pThisTab->nOldCurX = nNewX;
888 0 : pThisTab->nOldCurY = nNewY;
889 0 : pThisTab->mbOldCursorValid = true;
890 0 : }
891 :
892 891 : void ScViewData::ResetOldCursor()
893 : {
894 891 : pThisTab->mbOldCursorValid = false;
895 891 : }
896 :
897 0 : Rectangle ScViewData::GetEditArea( ScSplitPos eWhich, SCCOL nPosX, SCROW nPosY,
898 : vcl::Window* pWin, const ScPatternAttr* pPattern,
899 : bool bForceToTop )
900 : {
901 0 : return ScEditUtil( pDoc, nPosX, nPosY, nTabNo, GetScrPos(nPosX,nPosY,eWhich,true),
902 0 : pWin, nPPTX, nPPTY, GetZoomX(), GetZoomY() ).
903 0 : GetEditArea( pPattern, bForceToTop );
904 : }
905 :
906 0 : void ScViewData::SetEditEngine( ScSplitPos eWhich,
907 : ScEditEngineDefaulter* pNewEngine,
908 : vcl::Window* pWin, SCCOL nNewX, SCROW nNewY )
909 : {
910 0 : bool bLayoutRTL = pDoc->IsLayoutRTL( nTabNo );
911 0 : ScHSplitPos eHWhich = WhichH(eWhich);
912 :
913 0 : bool bWasThere = false;
914 0 : if (pEditView[eWhich])
915 : {
916 : // if the view is already therem don't call anything that changes the cursor position
917 0 : if (bEditActive[eWhich])
918 0 : bWasThere = true;
919 : else
920 0 : pEditView[eWhich]->SetEditEngine(pNewEngine);
921 :
922 0 : if (pEditView[eWhich]->GetWindow() != pWin)
923 : {
924 0 : pEditView[eWhich]->SetWindow(pWin);
925 : OSL_FAIL("EditView Window geaendert");
926 : }
927 : }
928 : else
929 : {
930 0 : pEditView[eWhich] = new EditView( pNewEngine, pWin );
931 :
932 0 : if (pDoc->GetDrawLayer() && pDoc->GetDrawLayer()->isTiledRendering())
933 : {
934 0 : pEditView[eWhich]->registerLibreOfficeKitCallback(pDoc->GetDrawLayer()->getLibreOfficeKitCallback(),
935 0 : pDoc->GetDrawLayer()->getLibreOfficeKitData());
936 0 : pEditView[eWhich]->setTiledRendering(true);
937 : }
938 : }
939 :
940 : // bei IdleFormat wird manchmal ein Cursor gemalt, wenn die View schon weg ist (23576)
941 :
942 0 : EEControlBits nEC = pNewEngine->GetControlWord();
943 0 : pNewEngine->SetControlWord(nEC & ~EEControlBits::DOIDLEFORMAT);
944 :
945 0 : EVControlBits nVC = pEditView[eWhich]->GetControlWord();
946 0 : pEditView[eWhich]->SetControlWord(nVC & ~EVControlBits::AUTOSCROLL);
947 :
948 0 : bEditActive[eWhich] = true;
949 :
950 0 : const ScPatternAttr* pPattern = pDoc->GetPattern( nNewX, nNewY, nTabNo );
951 : SvxCellHorJustify eJust = (SvxCellHorJustify)static_cast<const SvxHorJustifyItem&>(
952 0 : pPattern->GetItem( ATTR_HOR_JUSTIFY )).GetValue();
953 :
954 0 : bool bBreak = ( eJust == SVX_HOR_JUSTIFY_BLOCK ) ||
955 0 : static_cast<const SfxBoolItem&>(pPattern->GetItem(ATTR_LINEBREAK)).GetValue();
956 :
957 0 : bool bAsianVertical = pNewEngine->IsVertical(); // set by InputHandler
958 :
959 0 : Rectangle aPixRect = ScEditUtil( pDoc, nNewX,nNewY,nTabNo, GetScrPos(nNewX,nNewY,eWhich),
960 0 : pWin, nPPTX,nPPTY,GetZoomX(),GetZoomY() ).
961 0 : GetEditArea( pPattern, true );
962 :
963 : // when right-aligned, leave space for the cursor
964 : // in vertical mode, editing is always right-aligned
965 0 : if ( nEditAdjust == SVX_ADJUST_RIGHT || bAsianVertical )
966 0 : aPixRect.Right() += 1;
967 :
968 0 : Rectangle aOutputArea = pWin->PixelToLogic( aPixRect, GetLogicMode() );
969 0 : pEditView[eWhich]->SetOutputArea( aOutputArea );
970 :
971 0 : if ( bActive && eWhich == GetActivePart() )
972 : {
973 : // keep the part that has the active edit view available after
974 : // switching sheets or reference input on a different part
975 0 : eEditActivePart = eWhich;
976 :
977 : // modify members nEditCol etc. only if also extending for needed area
978 0 : nEditCol = nNewX;
979 0 : nEditRow = nNewY;
980 0 : const ScMergeAttr* pMergeAttr = static_cast<const ScMergeAttr*>(&pPattern->GetItem(ATTR_MERGE));
981 0 : nEditEndCol = nEditCol;
982 0 : if (pMergeAttr->GetColMerge() > 1)
983 0 : nEditEndCol += pMergeAttr->GetColMerge() - 1;
984 0 : nEditEndRow = nEditRow;
985 0 : if (pMergeAttr->GetRowMerge() > 1)
986 0 : nEditEndRow += pMergeAttr->GetRowMerge() - 1;
987 0 : nEditStartCol = nEditCol;
988 :
989 : // For growing use only the alignment value from the attribute, numbers
990 : // (existing or started) with default alignment extend to the right.
991 0 : bool bGrowCentered = ( eJust == SVX_HOR_JUSTIFY_CENTER );
992 0 : bool bGrowToLeft = ( eJust == SVX_HOR_JUSTIFY_RIGHT ); // visual left
993 0 : bool bGrowBackwards = bGrowToLeft; // logical left
994 0 : if ( bLayoutRTL )
995 0 : bGrowBackwards = !bGrowBackwards; // invert on RTL sheet
996 0 : if ( bAsianVertical )
997 0 : bGrowCentered = bGrowToLeft = bGrowBackwards = false; // keep old behavior for asian mode
998 :
999 : long nSizeXPix;
1000 0 : if (bBreak && !bAsianVertical)
1001 0 : nSizeXPix = aPixRect.GetWidth(); // Papersize -> kein H-Scrolling
1002 : else
1003 : {
1004 : OSL_ENSURE(pView,"keine View fuer EditView");
1005 :
1006 0 : if ( bGrowCentered )
1007 : {
1008 : // growing into both directions until one edge is reached
1009 : //! should be limited to whole cells in both directions
1010 0 : long nLeft = aPixRect.Left();
1011 0 : long nRight = pView->GetGridWidth(eHWhich) - aPixRect.Right();
1012 0 : nSizeXPix = aPixRect.GetWidth() + 2 * std::min( nLeft, nRight );
1013 : }
1014 0 : else if ( bGrowToLeft )
1015 0 : nSizeXPix = aPixRect.Right(); // space that's available in the window when growing to the left
1016 : else
1017 0 : nSizeXPix = pView->GetGridWidth(eHWhich) - aPixRect.Left();
1018 :
1019 0 : if ( nSizeXPix <= 0 )
1020 0 : nSizeXPix = aPixRect.GetWidth(); // editing outside to the right of the window -> keep cell width
1021 : }
1022 : OSL_ENSURE(pView,"keine View fuer EditView");
1023 0 : long nSizeYPix = pView->GetGridHeight(WhichV(eWhich)) - aPixRect.Top();
1024 0 : if ( nSizeYPix <= 0 )
1025 0 : nSizeYPix = aPixRect.GetHeight(); // editing outside below the window -> keep cell height
1026 :
1027 0 : Size aPaperSize = pView->GetActiveWin()->PixelToLogic( Size( nSizeXPix, nSizeYPix ), GetLogicMode() );
1028 0 : if ( bBreak && !bAsianVertical && SC_MOD()->GetInputOptions().GetTextWysiwyg() )
1029 : {
1030 : // if text is formatted for printer, use the exact same paper width
1031 : // (and same line breaks) as for output.
1032 :
1033 0 : Fraction aFract(1,1);
1034 : Rectangle aUtilRect = ScEditUtil( pDoc,nNewX,nNewY,nTabNo, Point(0,0), pWin,
1035 0 : HMM_PER_TWIPS, HMM_PER_TWIPS, aFract, aFract ).GetEditArea( pPattern, false );
1036 0 : aPaperSize.Width() = aUtilRect.GetWidth();
1037 : }
1038 0 : pNewEngine->SetPaperSize( aPaperSize );
1039 :
1040 : // sichtbarer Ausschnitt
1041 0 : Size aPaper = pNewEngine->GetPaperSize();
1042 0 : Rectangle aVis = pEditView[eWhich]->GetVisArea();
1043 0 : long nDiff = aVis.Right() - aVis.Left();
1044 0 : if ( nEditAdjust == SVX_ADJUST_RIGHT )
1045 : {
1046 0 : aVis.Right() = aPaper.Width() - 1;
1047 0 : bMoveArea = !bLayoutRTL;
1048 : }
1049 0 : else if ( nEditAdjust == SVX_ADJUST_CENTER )
1050 : {
1051 0 : aVis.Right() = ( aPaper.Width() - 1 + nDiff ) / 2;
1052 0 : bMoveArea = true; // always
1053 : }
1054 : else
1055 : {
1056 0 : aVis.Right() = nDiff;
1057 0 : bMoveArea = bLayoutRTL;
1058 : }
1059 0 : aVis.Left() = aVis.Right() - nDiff;
1060 : // #i49561# Important note:
1061 : // The set offset of the visible area of the EditView for centered and
1062 : // right alignment in horizontal layout is consider by instances of
1063 : // class <ScEditObjectViewForwarder> in its methods <LogicToPixel(..)>
1064 : // and <PixelToLogic(..)>. This is needed for the correct visibility
1065 : // of paragraphs in edit mode at the accessibility API.
1066 0 : pEditView[eWhich]->SetVisArea(aVis);
1067 : // UpdateMode has been disabled in ScInputHandler::StartTable
1068 : // must be enabled before EditGrowY (GetTextHeight)
1069 0 : pNewEngine->SetUpdateMode( true );
1070 :
1071 0 : pNewEngine->SetStatusEventHdl( LINK( this, ScViewData, EditEngineHdl ) );
1072 :
1073 0 : EditGrowY( true ); // adjust to existing text content
1074 0 : EditGrowX();
1075 :
1076 0 : Point aDocPos = pEditView[eWhich]->GetWindowPosTopLeft(0);
1077 0 : if (aDocPos.Y() < aOutputArea.Top())
1078 0 : pEditView[eWhich]->Scroll( 0, aOutputArea.Top() - aDocPos.Y() );
1079 : }
1080 :
1081 : // here bEditActive needs to be set already
1082 : // (due to Map-Mode during Paint)
1083 0 : if (!bWasThere)
1084 0 : pNewEngine->InsertView(pEditView[eWhich]);
1085 :
1086 : // background color of the cell
1087 0 : Color aBackCol = static_cast<const SvxBrushItem&>(pPattern->GetItem(ATTR_BACKGROUND)).GetColor();
1088 :
1089 0 : ScModule* pScMod = SC_MOD();
1090 0 : if ( aBackCol.GetTransparency() > 0 )
1091 : {
1092 0 : aBackCol.SetColor( pScMod->GetColorConfig().GetColorValue(svtools::DOCCOLOR).nColor );
1093 : }
1094 0 : pEditView[eWhich]->SetBackgroundColor( aBackCol );
1095 :
1096 0 : pEditView[eWhich]->Invalidate(); // needed?
1097 : // needed, wenn position changed
1098 0 : }
1099 :
1100 0 : IMPL_STATIC_LINK_NOARG(ScViewData, EmptyEditHdl)
1101 : {
1102 0 : return 0;
1103 : }
1104 :
1105 0 : IMPL_LINK( ScViewData, EditEngineHdl, EditStatus *, pStatus )
1106 : {
1107 0 : EditStatusFlags nStatus = pStatus->GetStatusWord();
1108 0 : if (nStatus & (EditStatusFlags::HSCROLL | EditStatusFlags::TEXTHEIGHTCHANGED | EditStatusFlags::TEXTWIDTHCHANGED | EditStatusFlags::CURSOROUT))
1109 : {
1110 0 : EditGrowY();
1111 0 : EditGrowX();
1112 :
1113 0 : if (nStatus & EditStatusFlags::CURSOROUT)
1114 : {
1115 0 : ScSplitPos eWhich = GetActivePart();
1116 0 : if (pEditView[eWhich])
1117 0 : pEditView[eWhich]->ShowCursor(false);
1118 : }
1119 : }
1120 0 : return 0;
1121 : }
1122 :
1123 0 : void ScViewData::EditGrowX()
1124 : {
1125 0 : ScDocument* pLocalDoc = GetDocument();
1126 :
1127 0 : ScSplitPos eWhich = GetActivePart();
1128 0 : ScHSplitPos eHWhich = WhichH(eWhich);
1129 0 : EditView* pCurView = pEditView[eWhich];
1130 :
1131 0 : if ( !pCurView || !bEditActive[eWhich])
1132 0 : return;
1133 :
1134 0 : bool bLayoutRTL = pLocalDoc->IsLayoutRTL( nTabNo );
1135 :
1136 : ScEditEngineDefaulter* pEngine =
1137 0 : static_cast<ScEditEngineDefaulter*>( pCurView->GetEditEngine() );
1138 0 : vcl::Window* pWin = pCurView->GetWindow();
1139 :
1140 0 : SCCOL nLeft = GetPosX(eHWhich);
1141 0 : SCCOL nRight = nLeft + VisibleCellsX(eHWhich);
1142 :
1143 0 : Size aSize = pEngine->GetPaperSize();
1144 0 : Rectangle aArea = pCurView->GetOutputArea();
1145 0 : long nOldRight = aArea.Right();
1146 :
1147 : // Margin ist schon bei der urspruenglichen Breite beruecksichtigt
1148 0 : long nTextWidth = pEngine->CalcTextWidth();
1149 :
1150 0 : bool bChanged = false;
1151 0 : bool bAsianVertical = pEngine->IsVertical();
1152 :
1153 : // get bGrow... variables the same way as in SetEditEngine
1154 0 : const ScPatternAttr* pPattern = pLocalDoc->GetPattern( nEditCol, nEditRow, nTabNo );
1155 : SvxCellHorJustify eJust = (SvxCellHorJustify)static_cast<const SvxHorJustifyItem&>(
1156 0 : pPattern->GetItem( ATTR_HOR_JUSTIFY )).GetValue();
1157 0 : bool bGrowCentered = ( eJust == SVX_HOR_JUSTIFY_CENTER );
1158 0 : bool bGrowToLeft = ( eJust == SVX_HOR_JUSTIFY_RIGHT ); // visual left
1159 0 : bool bGrowBackwards = bGrowToLeft; // logical left
1160 0 : if ( bLayoutRTL )
1161 0 : bGrowBackwards = !bGrowBackwards; // invert on RTL sheet
1162 0 : if ( bAsianVertical )
1163 0 : bGrowCentered = bGrowToLeft = bGrowBackwards = false; // keep old behavior for asian mode
1164 :
1165 0 : bool bUnevenGrow = false;
1166 0 : if ( bGrowCentered )
1167 : {
1168 0 : while (aArea.GetWidth() + 0 < nTextWidth && ( nEditStartCol > nLeft || nEditEndCol < nRight ) )
1169 : {
1170 0 : long nLogicLeft = 0;
1171 0 : if ( nEditStartCol > nLeft )
1172 : {
1173 0 : --nEditStartCol;
1174 0 : long nLeftPix = ToPixel( pLocalDoc->GetColWidth( nEditStartCol, nTabNo ), nPPTX );
1175 0 : nLogicLeft = pWin->PixelToLogic(Size(nLeftPix,0)).Width();
1176 : }
1177 0 : long nLogicRight = 0;
1178 0 : if ( nEditEndCol < nRight )
1179 : {
1180 0 : ++nEditEndCol;
1181 0 : long nRightPix = ToPixel( pLocalDoc->GetColWidth( nEditEndCol, nTabNo ), nPPTX );
1182 0 : nLogicRight = pWin->PixelToLogic(Size(nRightPix,0)).Width();
1183 : }
1184 :
1185 0 : aArea.Left() -= bLayoutRTL ? nLogicRight : nLogicLeft;
1186 0 : aArea.Right() += bLayoutRTL ? nLogicLeft : nLogicRight;
1187 :
1188 0 : if ( aArea.Right() > aArea.Left() + aSize.Width() - 1 )
1189 : {
1190 0 : long nCenter = ( aArea.Left() + aArea.Right() ) / 2;
1191 0 : long nHalf = aSize.Width() / 2;
1192 0 : aArea.Left() = nCenter - nHalf + 1;
1193 0 : aArea.Right() = nCenter + aSize.Width() - nHalf - 1;
1194 : }
1195 :
1196 0 : bChanged = true;
1197 0 : if ( nLogicLeft != nLogicRight )
1198 0 : bUnevenGrow = true;
1199 : }
1200 : }
1201 0 : else if ( bGrowBackwards )
1202 : {
1203 0 : while (aArea.GetWidth() + 0 < nTextWidth && nEditStartCol > nLeft)
1204 : {
1205 0 : --nEditStartCol;
1206 0 : long nPix = ToPixel( pLocalDoc->GetColWidth( nEditStartCol, nTabNo ), nPPTX );
1207 0 : long nLogicWidth = pWin->PixelToLogic(Size(nPix,0)).Width();
1208 0 : if ( !bLayoutRTL )
1209 0 : aArea.Left() -= nLogicWidth;
1210 : else
1211 0 : aArea.Right() += nLogicWidth;
1212 :
1213 0 : if ( aArea.Right() > aArea.Left() + aSize.Width() - 1 )
1214 : {
1215 0 : if ( !bLayoutRTL )
1216 0 : aArea.Left() = aArea.Right() - aSize.Width() + 1;
1217 : else
1218 0 : aArea.Right() = aArea.Left() + aSize.Width() - 1;
1219 : }
1220 :
1221 0 : bChanged = true;
1222 : }
1223 : }
1224 : else
1225 : {
1226 0 : while (aArea.GetWidth() + 0 < nTextWidth && nEditEndCol < nRight)
1227 : {
1228 0 : ++nEditEndCol;
1229 0 : long nPix = ToPixel( pLocalDoc->GetColWidth( nEditEndCol, nTabNo ), nPPTX );
1230 0 : long nLogicWidth = pWin->PixelToLogic(Size(nPix,0)).Width();
1231 0 : if ( bLayoutRTL )
1232 0 : aArea.Left() -= nLogicWidth;
1233 : else
1234 0 : aArea.Right() += nLogicWidth;
1235 :
1236 0 : if ( aArea.Right() > aArea.Left() + aSize.Width() - 1 )
1237 : {
1238 0 : if ( bLayoutRTL )
1239 0 : aArea.Left() = aArea.Right() - aSize.Width() + 1;
1240 : else
1241 0 : aArea.Right() = aArea.Left() + aSize.Width() - 1;
1242 : }
1243 :
1244 0 : bChanged = true;
1245 : }
1246 : }
1247 :
1248 0 : if (bChanged)
1249 : {
1250 0 : if ( bMoveArea || bGrowCentered || bGrowBackwards || bLayoutRTL )
1251 : {
1252 0 : Rectangle aVis = pCurView->GetVisArea();
1253 :
1254 0 : if ( bGrowCentered )
1255 : {
1256 : // switch to center-aligned (undo?) and reset VisArea to center
1257 :
1258 0 : pEngine->SetDefaultItem( SvxAdjustItem( SVX_ADJUST_CENTER, EE_PARA_JUST ) );
1259 :
1260 0 : long nCenter = aSize.Width() / 2;
1261 0 : long nVisSize = aArea.GetWidth();
1262 0 : aVis.Left() = nCenter - nVisSize / 2;
1263 0 : aVis.Right() = aVis.Left() + nVisSize - 1;
1264 : }
1265 0 : else if ( bGrowToLeft )
1266 : {
1267 : // switch to right-aligned (undo?) and reset VisArea to the right
1268 :
1269 0 : pEngine->SetDefaultItem( SvxAdjustItem( SVX_ADJUST_RIGHT, EE_PARA_JUST ) );
1270 :
1271 0 : aVis.Right() = aSize.Width() - 1;
1272 0 : aVis.Left() = aSize.Width() - aArea.GetWidth(); // with the new, increased area
1273 : }
1274 : else
1275 : {
1276 : // switch to left-aligned (undo?) and reset VisArea to the left
1277 :
1278 0 : pEngine->SetDefaultItem( SvxAdjustItem( SVX_ADJUST_LEFT, EE_PARA_JUST ) );
1279 :
1280 0 : long nMove = aVis.Left();
1281 0 : aVis.Left() = 0;
1282 0 : aVis.Right() -= nMove;
1283 : }
1284 0 : pCurView->SetVisArea( aVis );
1285 0 : bMoveArea = false;
1286 : }
1287 :
1288 0 : pCurView->SetOutputArea(aArea);
1289 :
1290 : // In vertical mode, the whole text is moved to the next cell (right-aligned),
1291 : // so everything must be repainted. Otherwise, paint only the new area.
1292 : // If growing in centered alignment, if the cells left and right have different sizes,
1293 : // the whole text will move, and may not even obscure all of the original display.
1294 0 : if ( bUnevenGrow )
1295 : {
1296 0 : aArea.Left() = pWin->PixelToLogic( Point(0,0) ).X();
1297 0 : aArea.Right() = pWin->PixelToLogic( aScrSize ).Width();
1298 : }
1299 0 : else if ( !bAsianVertical && !bGrowToLeft && !bGrowCentered )
1300 0 : aArea.Left() = nOldRight;
1301 0 : pWin->Invalidate(aArea);
1302 : }
1303 : }
1304 :
1305 0 : void ScViewData::EditGrowY( bool bInitial )
1306 : {
1307 0 : ScSplitPos eWhich = GetActivePart();
1308 0 : ScVSplitPos eVWhich = WhichV(eWhich);
1309 0 : EditView* pCurView = pEditView[eWhich];
1310 :
1311 0 : if ( !pCurView || !bEditActive[eWhich])
1312 0 : return;
1313 :
1314 0 : EVControlBits nControl = pEditView[eWhich]->GetControlWord();
1315 0 : if ( nControl & EVControlBits::AUTOSCROLL )
1316 : {
1317 : // if end of screen had already been reached and scrolling enabled,
1318 : // don't further try to grow the edit area
1319 :
1320 0 : pCurView->SetOutputArea( pCurView->GetOutputArea() ); // re-align to pixels
1321 0 : return;
1322 : }
1323 :
1324 0 : EditEngine* pEngine = pCurView->GetEditEngine();
1325 0 : vcl::Window* pWin = pCurView->GetWindow();
1326 :
1327 0 : SCROW nBottom = GetPosY(eVWhich) + VisibleCellsY(eVWhich);
1328 :
1329 0 : Size aSize = pEngine->GetPaperSize();
1330 0 : Rectangle aArea = pCurView->GetOutputArea();
1331 0 : long nOldBottom = aArea.Bottom();
1332 0 : long nTextHeight = pEngine->GetTextHeight();
1333 :
1334 : // When editing a formula in a cell with optimal height, allow a larger portion
1335 : // to be clipped before extending to following rows, to avoid obscuring cells for
1336 : // reference input (next row is likely to be useful in formulas).
1337 0 : long nAllowedExtra = SC_GROWY_SMALL_EXTRA;
1338 0 : if ( nEditEndRow == nEditRow && !( pDoc->GetRowFlags( nEditRow, nTabNo ) & CR_MANUALSIZE ) &&
1339 0 : pEngine->GetParagraphCount() <= 1 )
1340 : {
1341 : // If the (only) paragraph starts with a '=', it's a formula.
1342 : // If this is the initial call and the text is empty, allow the larger value, too,
1343 : // because this occurs in the normal progress of editing a formula.
1344 : // Subsequent calls with empty text might involve changed attributes (including
1345 : // font height), so they are treated like normal text.
1346 0 : OUString aText = pEngine->GetText( 0 );
1347 0 : if ( ( aText.isEmpty() && bInitial ) || aText.startsWith("=") )
1348 0 : nAllowedExtra = SC_GROWY_BIG_EXTRA;
1349 : }
1350 :
1351 0 : bool bChanged = false;
1352 0 : bool bMaxReached = false;
1353 0 : while (aArea.GetHeight() + nAllowedExtra < nTextHeight && nEditEndRow < nBottom && !bMaxReached)
1354 : {
1355 0 : ++nEditEndRow;
1356 0 : ScDocument* pLocalDoc = GetDocument();
1357 0 : long nPix = ToPixel( pLocalDoc->GetRowHeight( nEditEndRow, nTabNo ), nPPTY );
1358 0 : aArea.Bottom() += pWin->PixelToLogic(Size(0,nPix)).Height();
1359 :
1360 0 : if ( aArea.Bottom() > aArea.Top() + aSize.Height() - 1 )
1361 : {
1362 0 : aArea.Bottom() = aArea.Top() + aSize.Height() - 1;
1363 0 : bMaxReached = true; // don't occupy more cells beyond paper size
1364 : }
1365 :
1366 0 : bChanged = true;
1367 0 : nAllowedExtra = SC_GROWY_SMALL_EXTRA; // larger value is only for first row
1368 : }
1369 :
1370 0 : if (bChanged)
1371 : {
1372 0 : pCurView->SetOutputArea(aArea);
1373 :
1374 0 : if (nEditEndRow >= nBottom || bMaxReached)
1375 : {
1376 0 : if (!(nControl & EVControlBits::AUTOSCROLL))
1377 0 : pCurView->SetControlWord( nControl | EVControlBits::AUTOSCROLL );
1378 : }
1379 :
1380 0 : aArea.Top() = nOldBottom;
1381 0 : pWin->Invalidate(aArea);
1382 : }
1383 : }
1384 :
1385 2685 : void ScViewData::ResetEditView()
1386 : {
1387 2685 : EditEngine* pEngine = NULL;
1388 13425 : for (sal_uInt16 i=0; i<4; i++)
1389 10740 : if (pEditView[i])
1390 : {
1391 0 : if (bEditActive[i])
1392 : {
1393 0 : pEngine = pEditView[i]->GetEditEngine();
1394 0 : pEngine->RemoveView(pEditView[i]);
1395 0 : pEditView[i]->SetOutputArea( Rectangle() );
1396 : }
1397 0 : bEditActive[i] = false;
1398 : }
1399 :
1400 2685 : if (pEngine)
1401 0 : pEngine->SetStatusEventHdl( LINK( this, ScViewData, EmptyEditHdl ) );
1402 2685 : }
1403 :
1404 695 : void ScViewData::KillEditView()
1405 : {
1406 3475 : for (sal_uInt16 i=0; i<4; i++)
1407 2780 : if (pEditView[i])
1408 : {
1409 0 : if (bEditActive[i])
1410 0 : pEditView[i]->GetEditEngine()->RemoveView(pEditView[i]);
1411 0 : delete pEditView[i];
1412 0 : pEditView[i] = NULL;
1413 : }
1414 695 : }
1415 :
1416 0 : void ScViewData::GetEditView( ScSplitPos eWhich, EditView*& rViewPtr, SCCOL& rCol, SCROW& rRow )
1417 : {
1418 0 : rViewPtr = pEditView[eWhich];
1419 0 : rCol = nEditCol;
1420 0 : rRow = nEditRow;
1421 0 : }
1422 :
1423 679 : void ScViewData::CreateTabData( SCTAB nNewTab )
1424 : {
1425 679 : EnsureTabDataSize(nNewTab + 1);
1426 :
1427 679 : if (!maTabData[nNewTab])
1428 : {
1429 47 : maTabData[nNewTab] = new ScViewDataTable;
1430 :
1431 47 : maTabData[nNewTab]->eZoomType = eDefZoomType;
1432 47 : maTabData[nNewTab]->aZoomX = aDefZoomX;
1433 47 : maTabData[nNewTab]->aZoomY = aDefZoomY;
1434 47 : maTabData[nNewTab]->aPageZoomX = aDefPageZoomX;
1435 47 : maTabData[nNewTab]->aPageZoomY = aDefPageZoomY;
1436 : }
1437 679 : }
1438 :
1439 0 : void ScViewData::CreateSelectedTabData()
1440 : {
1441 0 : ScMarkData::iterator itr = mpMarkData->begin(), itrEnd = mpMarkData->end();
1442 0 : for (; itr != itrEnd; ++itr)
1443 0 : CreateTabData(*itr);
1444 0 : }
1445 :
1446 1497 : void ScViewData::EnsureTabDataSize(size_t nSize)
1447 : {
1448 1497 : if (nSize >= maTabData.size())
1449 : {
1450 410 : size_t n = nSize - maTabData.size() + 1;
1451 410 : maTabData.insert(maTabData.end(), n, NULL);
1452 : }
1453 1497 : }
1454 :
1455 631 : void ScViewData::SetTabNo( SCTAB nNewTab )
1456 : {
1457 631 : if (!ValidTab(nNewTab))
1458 : {
1459 : OSL_FAIL("falsche Tabellennummer");
1460 631 : return;
1461 : }
1462 :
1463 631 : nTabNo = nNewTab;
1464 631 : CreateTabData(nTabNo);
1465 631 : pThisTab = maTabData[nTabNo];
1466 :
1467 631 : CalcPPT(); // for common column width correction
1468 631 : RecalcPixPos(); //! nicht immer noetig!
1469 : }
1470 :
1471 14 : void ScViewData::SetActivePart( ScSplitPos eNewActive )
1472 : {
1473 14 : pThisTab->eWhichActive = eNewActive;
1474 14 : }
1475 :
1476 217 : Point ScViewData::GetScrPos( SCCOL nWhereX, SCROW nWhereY, ScHSplitPos eWhich ) const
1477 : {
1478 : OSL_ENSURE( eWhich==SC_SPLIT_LEFT || eWhich==SC_SPLIT_RIGHT, "Falsche Position" );
1479 217 : ScSplitPos ePos = ( eWhich == SC_SPLIT_LEFT ) ? SC_SPLIT_BOTTOMLEFT : SC_SPLIT_BOTTOMRIGHT;
1480 217 : return GetScrPos( nWhereX, nWhereY, ePos );
1481 : }
1482 :
1483 320 : Point ScViewData::GetScrPos( SCCOL nWhereX, SCROW nWhereY, ScVSplitPos eWhich ) const
1484 : {
1485 : OSL_ENSURE( eWhich==SC_SPLIT_TOP || eWhich==SC_SPLIT_BOTTOM, "Falsche Position" );
1486 320 : ScSplitPos ePos = ( eWhich == SC_SPLIT_TOP ) ? SC_SPLIT_TOPLEFT : SC_SPLIT_BOTTOMLEFT;
1487 320 : return GetScrPos( nWhereX, nWhereY, ePos );
1488 : }
1489 :
1490 25382 : Point ScViewData::GetScrPos( SCCOL nWhereX, SCROW nWhereY, ScSplitPos eWhich,
1491 : bool bAllowNeg ) const
1492 : {
1493 25382 : ScHSplitPos eWhichX = SC_SPLIT_LEFT;
1494 25382 : ScVSplitPos eWhichY = SC_SPLIT_BOTTOM;
1495 25382 : switch( eWhich )
1496 : {
1497 : case SC_SPLIT_TOPLEFT:
1498 49 : eWhichX = SC_SPLIT_LEFT;
1499 49 : eWhichY = SC_SPLIT_TOP;
1500 49 : break;
1501 : case SC_SPLIT_TOPRIGHT:
1502 6 : eWhichX = SC_SPLIT_RIGHT;
1503 6 : eWhichY = SC_SPLIT_TOP;
1504 6 : break;
1505 : case SC_SPLIT_BOTTOMLEFT:
1506 25316 : eWhichX = SC_SPLIT_LEFT;
1507 25316 : eWhichY = SC_SPLIT_BOTTOM;
1508 25316 : break;
1509 : case SC_SPLIT_BOTTOMRIGHT:
1510 11 : eWhichX = SC_SPLIT_RIGHT;
1511 11 : eWhichY = SC_SPLIT_BOTTOM;
1512 11 : break;
1513 : }
1514 :
1515 25382 : if (pView)
1516 : {
1517 25382 : const_cast<ScViewData*>(this)->aScrSize.Width() = pView->GetGridWidth(eWhichX);
1518 25382 : const_cast<ScViewData*>(this)->aScrSize.Height() = pView->GetGridHeight(eWhichY);
1519 : }
1520 :
1521 : sal_uInt16 nTSize;
1522 25382 : ScDrawLayer* pModel = GetDocument()->GetDrawLayer();
1523 25382 : bool bIsTiledRendering = pModel && pModel->isTiledRendering();
1524 :
1525 25382 : SCCOL nPosX = GetPosX(eWhichX);
1526 : SCCOL nX;
1527 :
1528 25382 : long nScrPosX=0;
1529 25382 : if (nWhereX >= nPosX)
1530 75927 : for (nX = nPosX; nX < nWhereX && (bAllowNeg || bIsTiledRendering || nScrPosX <= aScrSize.Width()); nX++)
1531 : {
1532 50632 : if ( nX > MAXCOL )
1533 0 : nScrPosX = 65535;
1534 : else
1535 : {
1536 50632 : nTSize = pDoc->GetColWidth( nX, nTabNo );
1537 50632 : if (nTSize)
1538 : {
1539 50303 : long nSizeXPix = ToPixel( nTSize, nPPTX );
1540 50303 : nScrPosX += nSizeXPix;
1541 : }
1542 : }
1543 : }
1544 87 : else if (bAllowNeg)
1545 6 : for (nX=nPosX; nX>nWhereX;)
1546 : {
1547 4 : --nX;
1548 4 : nTSize = pDoc->GetColWidth( nX, nTabNo );
1549 4 : if (nTSize)
1550 : {
1551 4 : long nSizeXPix = ToPixel( nTSize, nPPTX );
1552 4 : nScrPosX -= nSizeXPix;
1553 : }
1554 : }
1555 :
1556 25382 : SCROW nPosY = GetPosY(eWhichY);
1557 : SCROW nY;
1558 :
1559 25382 : long nScrPosY=0;
1560 25382 : if (nWhereY >= nPosY)
1561 108400 : for (nY = nPosY; nY < nWhereY && (bAllowNeg || bIsTiledRendering || nScrPosY <= aScrSize.Height()); nY++)
1562 : {
1563 83057 : if ( nY > MAXROW )
1564 0 : nScrPosY = 65535;
1565 : else
1566 : {
1567 83057 : nTSize = pDoc->GetRowHeight( nY, nTabNo );
1568 83057 : if (nTSize)
1569 : {
1570 82889 : long nSizeYPix = ToPixel( nTSize, nPPTY );
1571 82889 : nScrPosY += nSizeYPix;
1572 : }
1573 168 : else if ( nY < MAXROW )
1574 : {
1575 : // skip multiple hidden rows (forward only for now)
1576 168 : SCROW nNext = pDoc->FirstVisibleRow(nY + 1, MAXROW, nTabNo);
1577 168 : if ( nNext > MAXROW )
1578 0 : nY = MAXROW;
1579 : else
1580 168 : nY = nNext - 1; // +=nDir advances to next visible row
1581 : }
1582 : }
1583 : }
1584 39 : else if (bAllowNeg)
1585 187 : for (nY=nPosY; nY>nWhereY;)
1586 : {
1587 175 : --nY;
1588 175 : nTSize = pDoc->GetRowHeight( nY, nTabNo );
1589 175 : if (nTSize)
1590 : {
1591 175 : long nSizeYPix = ToPixel( nTSize, nPPTY );
1592 175 : nScrPosY -= nSizeYPix;
1593 : }
1594 : }
1595 :
1596 25382 : if ( pDoc->IsLayoutRTL( nTabNo ) )
1597 : {
1598 : // mirror horizontal position
1599 10 : nScrPosX = aScrSize.Width() - 1 - nScrPosX;
1600 : }
1601 :
1602 25382 : if (!bIsTiledRendering)
1603 : {
1604 25382 : if (nScrPosX > 32767)
1605 0 : nScrPosX = 32767;
1606 25382 : if (nScrPosY > 32767)
1607 0 : nScrPosY = 32767;
1608 : }
1609 :
1610 25382 : return Point( nScrPosX, nScrPosY );
1611 : }
1612 :
1613 : // Number of cells on a screen
1614 27253 : SCCOL ScViewData::CellsAtX( SCsCOL nPosX, SCsCOL nDir, ScHSplitPos eWhichX, sal_uInt16 nScrSizeX ) const
1615 : {
1616 : OSL_ENSURE( nDir==1 || nDir==-1, "falscher CellsAt Aufruf" );
1617 :
1618 27253 : if (pView)
1619 27253 : const_cast<ScViewData*>(this)->aScrSize.Width() = pView->GetGridWidth(eWhichX);
1620 :
1621 : SCsCOL nX;
1622 27253 : sal_uInt16 nScrPosX = 0;
1623 27253 : if (nScrSizeX == SC_SIZE_NONE) nScrSizeX = (sal_uInt16) aScrSize.Width();
1624 :
1625 27253 : if (nDir==1)
1626 27220 : nX = nPosX; // vorwaerts
1627 : else
1628 33 : nX = nPosX-1; // rueckwaerts
1629 :
1630 27253 : bool bOut = false;
1631 278705 : for ( ; nScrPosX<=nScrSizeX && !bOut; nX = sal::static_int_cast<SCsCOL>(nX + nDir) )
1632 : {
1633 251452 : SCsCOL nColNo = nX;
1634 251452 : if ( nColNo < 0 || nColNo > MAXCOL )
1635 75 : bOut = true;
1636 : else
1637 : {
1638 251377 : sal_uInt16 nTSize = pDoc->GetColWidth( nColNo, nTabNo );
1639 251377 : if (nTSize)
1640 : {
1641 250310 : long nSizeXPix = ToPixel( nTSize, nPPTX );
1642 250310 : nScrPosX = sal::static_int_cast<sal_uInt16>( nScrPosX + (sal_uInt16) nSizeXPix );
1643 : }
1644 : }
1645 : }
1646 :
1647 27253 : if (nDir==1)
1648 27220 : nX = sal::static_int_cast<SCsCOL>( nX - nPosX );
1649 : else
1650 33 : nX = (nPosX-1)-nX;
1651 :
1652 27253 : if (nX>0) --nX;
1653 27253 : return nX;
1654 : }
1655 :
1656 36345 : SCROW ScViewData::CellsAtY( SCsROW nPosY, SCsROW nDir, ScVSplitPos eWhichY, sal_uInt16 nScrSizeY ) const
1657 : {
1658 : OSL_ENSURE( nDir==1 || nDir==-1, "falscher CellsAt Aufruf" );
1659 :
1660 36345 : if (pView)
1661 36345 : const_cast<ScViewData*>(this)->aScrSize.Height() = pView->GetGridHeight(eWhichY);
1662 :
1663 36345 : if (nScrSizeY == SC_SIZE_NONE) nScrSizeY = (sal_uInt16) aScrSize.Height();
1664 :
1665 : SCROW nY;
1666 :
1667 36345 : if (nDir==1)
1668 : {
1669 : // forward
1670 36301 : nY = nPosY;
1671 36301 : long nScrPosY = 0;
1672 36301 : AddPixelsWhile( nScrPosY, nScrSizeY, nY, MAXROW, nPPTY, pDoc, nTabNo);
1673 : // Original loop ended on last evaluated +1 or if that was MAXROW even
1674 : // on MAXROW+2.
1675 36301 : nY += (nY == MAXROW ? 2 : 1);
1676 36301 : nY -= nPosY;
1677 : }
1678 : else
1679 : {
1680 : // backward
1681 44 : nY = nPosY-1;
1682 44 : long nScrPosY = 0;
1683 44 : AddPixelsWhileBackward( nScrPosY, nScrSizeY, nY, 0, nPPTY, pDoc, nTabNo);
1684 : // Original loop ended on last evaluated -1 or if that was 0 even on
1685 : // -2.
1686 44 : nY -= (nY == 0 ? 2 : 1);
1687 44 : nY = (nPosY-1)-nY;
1688 : }
1689 :
1690 36345 : if (nY>0) --nY;
1691 36345 : return nY;
1692 : }
1693 :
1694 27139 : SCCOL ScViewData::VisibleCellsX( ScHSplitPos eWhichX ) const
1695 : {
1696 27139 : return CellsAtX( GetPosX( eWhichX ), 1, eWhichX, SC_SIZE_NONE );
1697 : }
1698 :
1699 27150 : SCROW ScViewData::VisibleCellsY( ScVSplitPos eWhichY ) const
1700 : {
1701 27150 : return CellsAtY( GetPosY( eWhichY ), 1, eWhichY, SC_SIZE_NONE );
1702 : }
1703 :
1704 0 : SCCOL ScViewData::PrevCellsX( ScHSplitPos eWhichX ) const
1705 : {
1706 0 : return CellsAtX( GetPosX( eWhichX ), -1, eWhichX, SC_SIZE_NONE );
1707 : }
1708 :
1709 0 : SCROW ScViewData::PrevCellsY( ScVSplitPos eWhichY ) const
1710 : {
1711 0 : return CellsAtY( GetPosY( eWhichY ), -1, eWhichY, SC_SIZE_NONE );
1712 : }
1713 :
1714 6678 : bool ScViewData::GetMergeSizePixel( SCCOL nX, SCROW nY, long& rSizeXPix, long& rSizeYPix ) const
1715 : {
1716 6678 : const ScMergeAttr* pMerge = static_cast<const ScMergeAttr*>( pDoc->GetAttr( nX,nY,nTabNo, ATTR_MERGE ) );
1717 6678 : if ( pMerge->GetColMerge() > 1 || pMerge->GetRowMerge() > 1 )
1718 : {
1719 0 : long nOutWidth = 0;
1720 0 : long nOutHeight = 0;
1721 0 : SCCOL nCountX = pMerge->GetColMerge();
1722 0 : for (SCCOL i=0; i<nCountX; i++)
1723 0 : nOutWidth += ToPixel( pDoc->GetColWidth(nX+i,nTabNo), nPPTX );
1724 0 : SCROW nCountY = pMerge->GetRowMerge();
1725 :
1726 0 : for (SCROW nRow = nY; nRow <= nY+nCountY-1; ++nRow)
1727 : {
1728 0 : SCROW nLastRow = nRow;
1729 0 : if (pDoc->RowHidden(nRow, nTabNo, NULL, &nLastRow))
1730 : {
1731 0 : nRow = nLastRow;
1732 0 : continue;
1733 : }
1734 :
1735 0 : sal_uInt16 nHeight = pDoc->GetRowHeight(nRow, nTabNo);
1736 0 : nOutHeight += ToPixel(nHeight, nPPTY);
1737 : }
1738 :
1739 0 : rSizeXPix = nOutWidth;
1740 0 : rSizeYPix = nOutHeight;
1741 0 : return true;
1742 : }
1743 : else
1744 : {
1745 6678 : rSizeXPix = ToPixel( pDoc->GetColWidth( nX, nTabNo ), nPPTX );
1746 6678 : rSizeYPix = ToPixel( pDoc->GetRowHeight( nY, nTabNo ), nPPTY );
1747 6678 : return false;
1748 : }
1749 : }
1750 :
1751 10 : bool ScViewData::GetPosFromPixel( long nClickX, long nClickY, ScSplitPos eWhich,
1752 : SCsCOL& rPosX, SCsROW& rPosY,
1753 : bool bTestMerge, bool bRepair, bool bNextIfLarge )
1754 : {
1755 : // special handling of 0 is now in ScViewFunctionSet::SetCursorAtPoint
1756 :
1757 10 : ScHSplitPos eHWhich = WhichH(eWhich);
1758 10 : ScVSplitPos eVWhich = WhichV(eWhich);
1759 :
1760 10 : if ( pDoc->IsLayoutRTL( nTabNo ) )
1761 : {
1762 : // mirror horizontal position
1763 0 : if (pView)
1764 0 : aScrSize.Width() = pView->GetGridWidth(eHWhich);
1765 0 : nClickX = aScrSize.Width() - 1 - nClickX;
1766 : }
1767 :
1768 10 : SCsCOL nStartPosX = GetPosX(eHWhich);
1769 10 : SCsROW nStartPosY = GetPosY(eVWhich);
1770 10 : rPosX = nStartPosX;
1771 10 : rPosY = nStartPosY;
1772 10 : long nScrX = 0;
1773 10 : long nScrY = 0;
1774 :
1775 10 : if (nClickX > 0)
1776 : {
1777 43 : while ( rPosX<=MAXCOL && nClickX >= nScrX )
1778 : {
1779 29 : nScrX += ToPixel( pDoc->GetColWidth( rPosX, nTabNo ), nPPTX );
1780 29 : ++rPosX;
1781 : }
1782 7 : --rPosX;
1783 : }
1784 : else
1785 : {
1786 6 : while ( rPosX>0 && nClickX < nScrX )
1787 : {
1788 0 : --rPosX;
1789 0 : nScrX -= ToPixel( pDoc->GetColWidth( rPosX, nTabNo ), nPPTX );
1790 : }
1791 : }
1792 :
1793 10 : if (nClickY > 0)
1794 8 : AddPixelsWhile( nScrY, nClickY, rPosY, MAXROW, nPPTY, pDoc, nTabNo );
1795 : else
1796 : {
1797 : /* TODO: could need some "SubPixelsWhileBackward" method */
1798 4 : while ( rPosY>0 && nClickY < nScrY )
1799 : {
1800 0 : --rPosY;
1801 0 : nScrY -= ToPixel( pDoc->GetRowHeight( rPosY, nTabNo ), nPPTY );
1802 : }
1803 : }
1804 :
1805 10 : if (bNextIfLarge) // cells to big?
1806 : {
1807 10 : if ( rPosX == nStartPosX && nClickX > 0 )
1808 : {
1809 2 : if (pView)
1810 2 : aScrSize.Width() = pView->GetGridWidth(eHWhich);
1811 2 : if ( nClickX > aScrSize.Width() )
1812 0 : ++rPosX;
1813 : }
1814 10 : if ( rPosY == nStartPosY && nClickY > 0 )
1815 : {
1816 2 : if (pView)
1817 2 : aScrSize.Height() = pView->GetGridHeight(eVWhich);
1818 2 : if ( nClickY > aScrSize.Height() )
1819 0 : ++rPosY;
1820 : }
1821 : }
1822 :
1823 10 : if (rPosX<0) rPosX=0;
1824 10 : if (rPosX>MAXCOL) rPosX=MAXCOL;
1825 10 : if (rPosY<0) rPosY=0;
1826 10 : if (rPosY>MAXROW) rPosY=MAXROW;
1827 :
1828 10 : if (bTestMerge)
1829 : {
1830 : // public method to adapt position
1831 6 : SCCOL nOrigX = rPosX;
1832 6 : SCROW nOrigY = rPosY;
1833 6 : pDoc->SkipOverlapped(rPosX, rPosY, nTabNo);
1834 6 : bool bHOver = (nOrigX != rPosX);
1835 6 : bool bVOver = (nOrigY != rPosY);
1836 :
1837 6 : if ( bRepair && ( bHOver || bVOver ) )
1838 : {
1839 : const ScMergeAttr* pMerge = static_cast<const ScMergeAttr*>(
1840 0 : pDoc->GetAttr( rPosX, rPosY, nTabNo, ATTR_MERGE ) );
1841 0 : if ( ( bHOver && pMerge->GetColMerge() <= 1 ) ||
1842 0 : ( bVOver && pMerge->GetRowMerge() <= 1 ) )
1843 : {
1844 : OSL_FAIL("Merge-Fehler gefunden");
1845 :
1846 0 : pDoc->RemoveFlagsTab( 0,0, MAXCOL,MAXROW, nTabNo, SC_MF_HOR | SC_MF_VER );
1847 0 : SCCOL nEndCol = MAXCOL;
1848 0 : SCROW nEndRow = MAXROW;
1849 0 : pDoc->ExtendMerge( 0,0, nEndCol,nEndRow, nTabNo, true );
1850 0 : if (pDocShell)
1851 0 : pDocShell->PostPaint( ScRange(0,0,nTabNo,MAXCOL,MAXROW,nTabNo), PAINT_GRID );
1852 : }
1853 : }
1854 : }
1855 :
1856 10 : return false;
1857 : }
1858 :
1859 2 : void ScViewData::GetMouseQuadrant( const Point& rClickPos, ScSplitPos eWhich,
1860 : SCsCOL nPosX, SCsROW nPosY, bool& rLeft, bool& rTop )
1861 : {
1862 2 : bool bLayoutRTL = pDoc->IsLayoutRTL( nTabNo );
1863 2 : long nLayoutSign = bLayoutRTL ? -1 : 1;
1864 :
1865 2 : Point aCellStart = GetScrPos( nPosX, nPosY, eWhich, true );
1866 : long nSizeX;
1867 : long nSizeY;
1868 2 : GetMergeSizePixel( nPosX, nPosY, nSizeX, nSizeY );
1869 2 : rLeft = ( rClickPos.X() - aCellStart.X() ) * nLayoutSign <= nSizeX / 2;
1870 2 : rTop = rClickPos.Y() - aCellStart.Y() <= nSizeY / 2;
1871 2 : }
1872 :
1873 63 : void ScViewData::SetPosX( ScHSplitPos eWhich, SCCOL nNewPosX )
1874 : {
1875 : // in the tiled rendering case, nPosX [the leftmost visible column] must be 0
1876 63 : ScDrawLayer* pModel = GetDocument()->GetDrawLayer();
1877 63 : bool bIsTiledRendering = pModel && pModel->isTiledRendering();
1878 63 : if (nNewPosX != 0 && !bIsTiledRendering)
1879 : {
1880 34 : SCCOL nOldPosX = pThisTab->nPosX[eWhich];
1881 34 : long nTPosX = pThisTab->nTPosX[eWhich];
1882 34 : long nPixPosX = pThisTab->nPixPosX[eWhich];
1883 : SCCOL i;
1884 34 : if ( nNewPosX > nOldPosX )
1885 6954 : for ( i=nOldPosX; i<nNewPosX; i++ )
1886 : {
1887 6923 : long nThis = pDoc->GetColWidth( i,nTabNo );
1888 6923 : nTPosX -= nThis;
1889 6923 : nPixPosX -= ToPixel(sal::static_int_cast<sal_uInt16>(nThis), nPPTX);
1890 : }
1891 : else
1892 3 : for ( i=nNewPosX; i<nOldPosX; i++ )
1893 : {
1894 0 : long nThis = pDoc->GetColWidth( i,nTabNo );
1895 0 : nTPosX += nThis;
1896 0 : nPixPosX += ToPixel(sal::static_int_cast<sal_uInt16>(nThis), nPPTX);
1897 : }
1898 :
1899 34 : pThisTab->nPosX[eWhich] = nNewPosX;
1900 34 : pThisTab->nTPosX[eWhich] = nTPosX;
1901 34 : pThisTab->nMPosX[eWhich] = (long) (nTPosX * HMM_PER_TWIPS);
1902 34 : pThisTab->nPixPosX[eWhich] = nPixPosX;
1903 : }
1904 : else
1905 : {
1906 29 : pThisTab->nPixPosX[eWhich] =
1907 58 : pThisTab->nTPosX[eWhich] =
1908 58 : pThisTab->nMPosX[eWhich] =
1909 116 : pThisTab->nPosX[eWhich] = 0;
1910 : }
1911 63 : }
1912 :
1913 85 : void ScViewData::SetPosY( ScVSplitPos eWhich, SCROW nNewPosY )
1914 : {
1915 : // in the tiled rendering case, nPosY [the topmost visible row] must be 0
1916 85 : ScDrawLayer* pModel = GetDocument()->GetDrawLayer();
1917 85 : bool bIsTiledRendering = pModel && pModel->isTiledRendering();
1918 85 : if (nNewPosY != 0 && !bIsTiledRendering)
1919 : {
1920 40 : SCROW nOldPosY = pThisTab->nPosY[eWhich];
1921 40 : long nTPosY = pThisTab->nTPosY[eWhich];
1922 40 : long nPixPosY = pThisTab->nPixPosY[eWhich];
1923 : SCROW i, nHeightEndRow;
1924 40 : if ( nNewPosY > nOldPosY )
1925 96 : for ( i=nOldPosY; i<nNewPosY; i++ )
1926 : {
1927 62 : long nThis = pDoc->GetRowHeight( i, nTabNo, NULL, &nHeightEndRow );
1928 62 : SCROW nRows = std::min( nNewPosY, nHeightEndRow + 1) - i;
1929 62 : i = nHeightEndRow;
1930 62 : nTPosY -= nThis * nRows;
1931 62 : nPixPosY -= ToPixel(sal::static_int_cast<sal_uInt16>(nThis), nPPTY) * nRows;
1932 : }
1933 : else
1934 16 : for ( i=nNewPosY; i<nOldPosY; i++ )
1935 : {
1936 10 : long nThis = pDoc->GetRowHeight( i, nTabNo, NULL, &nHeightEndRow );
1937 10 : SCROW nRows = std::min( nOldPosY, nHeightEndRow + 1) - i;
1938 10 : i = nHeightEndRow;
1939 10 : nTPosY += nThis * nRows;
1940 10 : nPixPosY += ToPixel(sal::static_int_cast<sal_uInt16>(nThis), nPPTY) * nRows;
1941 : }
1942 :
1943 40 : pThisTab->nPosY[eWhich] = nNewPosY;
1944 40 : pThisTab->nTPosY[eWhich] = nTPosY;
1945 40 : pThisTab->nMPosY[eWhich] = (long) (nTPosY * HMM_PER_TWIPS);
1946 40 : pThisTab->nPixPosY[eWhich] = nPixPosY;
1947 : }
1948 : else
1949 : {
1950 45 : pThisTab->nPixPosY[eWhich] =
1951 90 : pThisTab->nTPosY[eWhich] =
1952 90 : pThisTab->nMPosY[eWhich] =
1953 180 : pThisTab->nPosY[eWhich] = 0;
1954 : }
1955 85 : }
1956 :
1957 2028 : void ScViewData::RecalcPixPos() // after zoom changes
1958 : {
1959 6084 : for (sal_uInt16 eWhich=0; eWhich<2; eWhich++)
1960 : {
1961 4056 : long nPixPosX = 0;
1962 4056 : SCCOL nPosX = pThisTab->nPosX[eWhich];
1963 16370 : for (SCCOL i=0; i<nPosX; i++)
1964 12314 : nPixPosX -= ToPixel(pDoc->GetColWidth(i,nTabNo), nPPTX);
1965 4056 : pThisTab->nPixPosX[eWhich] = nPixPosX;
1966 :
1967 4056 : long nPixPosY = 0;
1968 4056 : SCROW nPosY = pThisTab->nPosY[eWhich];
1969 9179712 : for (SCROW j=0; j<nPosY; j++)
1970 9175656 : nPixPosY -= ToPixel(pDoc->GetRowHeight(j,nTabNo), nPPTY);
1971 4056 : pThisTab->nPixPosY[eWhich] = nPixPosY;
1972 : }
1973 2028 : }
1974 :
1975 3342 : const MapMode& ScViewData::GetLogicMode( ScSplitPos eWhich )
1976 : {
1977 3342 : aLogicMode.SetOrigin( Point( pThisTab->nMPosX[WhichH(eWhich)],
1978 6684 : pThisTab->nMPosY[WhichV(eWhich)] ) );
1979 3342 : return aLogicMode;
1980 : }
1981 :
1982 26590 : const MapMode& ScViewData::GetLogicMode()
1983 : {
1984 26590 : aLogicMode.SetOrigin( Point() );
1985 26590 : return aLogicMode;
1986 : }
1987 :
1988 0 : void ScViewData::SetScreen( SCCOL nCol1, SCROW nRow1, SCCOL nCol2, SCROW nRow2 )
1989 : {
1990 : SCCOL nCol;
1991 : SCROW nRow;
1992 : sal_uInt16 nTSize;
1993 : long nSizePix;
1994 0 : long nScrPosX = 0;
1995 0 : long nScrPosY = 0;
1996 :
1997 0 : SetActivePart( SC_SPLIT_BOTTOMLEFT );
1998 0 : SetPosX( SC_SPLIT_LEFT, nCol1 );
1999 0 : SetPosY( SC_SPLIT_BOTTOM, nRow1 );
2000 :
2001 0 : for (nCol=nCol1; nCol<=nCol2; nCol++)
2002 : {
2003 0 : nTSize = pDoc->GetColWidth( nCol, nTabNo );
2004 0 : if (nTSize)
2005 : {
2006 0 : nSizePix = ToPixel( nTSize, nPPTX );
2007 0 : nScrPosX += (sal_uInt16) nSizePix;
2008 : }
2009 : }
2010 :
2011 0 : for (nRow=nRow1; nRow<=nRow2; nRow++)
2012 : {
2013 0 : nTSize = pDoc->GetRowHeight( nRow, nTabNo );
2014 0 : if (nTSize)
2015 : {
2016 0 : nSizePix = ToPixel( nTSize, nPPTY );
2017 0 : nScrPosY += (sal_uInt16) nSizePix;
2018 : }
2019 : }
2020 :
2021 0 : aScrSize = Size( nScrPosX, nScrPosY );
2022 0 : }
2023 :
2024 6 : void ScViewData::SetScreenPos( const Point& rVisAreaStart )
2025 : {
2026 : long nSize;
2027 : long nTwips;
2028 : long nAdd;
2029 : bool bEnd;
2030 :
2031 6 : nSize = 0;
2032 6 : nTwips = (long) (rVisAreaStart.X() / HMM_PER_TWIPS);
2033 6 : if ( pDoc->IsLayoutRTL( nTabNo ) )
2034 0 : nTwips = -nTwips;
2035 6 : SCCOL nX1 = 0;
2036 6 : bEnd = false;
2037 19 : while (!bEnd)
2038 : {
2039 7 : nAdd = (long) pDoc->GetColWidth(nX1,nTabNo);
2040 7 : if (nSize+nAdd <= nTwips+1 && nX1<MAXCOL)
2041 : {
2042 1 : nSize += nAdd;
2043 1 : ++nX1;
2044 : }
2045 : else
2046 6 : bEnd = true;
2047 : }
2048 :
2049 6 : nSize = 0;
2050 6 : nTwips = (long) (rVisAreaStart.Y() / HMM_PER_TWIPS);
2051 6 : SCROW nY1 = 0;
2052 6 : bEnd = false;
2053 19 : while (!bEnd)
2054 : {
2055 7 : nAdd = (long) pDoc->GetRowHeight(nY1,nTabNo);
2056 7 : if (nSize+nAdd <= nTwips+1 && nY1<MAXROW)
2057 : {
2058 1 : nSize += nAdd;
2059 1 : ++nY1;
2060 : }
2061 : else
2062 6 : bEnd = true;
2063 : }
2064 :
2065 6 : SetActivePart( SC_SPLIT_BOTTOMLEFT );
2066 6 : SetPosX( SC_SPLIT_LEFT, nX1 );
2067 6 : SetPosY( SC_SPLIT_BOTTOM, nY1 );
2068 :
2069 6 : SetCurX( nX1 );
2070 6 : SetCurY( nY1 );
2071 6 : }
2072 :
2073 5 : void ScViewData::SetScreen( const Rectangle& rVisArea )
2074 : {
2075 5 : SetScreenPos( rVisArea.TopLeft() );
2076 :
2077 : // here without GetOutputFactor(), since it's for the output into a Metafile
2078 :
2079 5 : aScrSize = rVisArea.GetSize();
2080 5 : aScrSize.Width() = (long)
2081 5 : ( aScrSize.Width() * ScGlobal::nScreenPPTX / HMM_PER_TWIPS );
2082 5 : aScrSize.Height() = (long)
2083 5 : ( aScrSize.Height() * ScGlobal::nScreenPPTY / HMM_PER_TWIPS );
2084 5 : }
2085 :
2086 0 : ScDocFunc& ScViewData::GetDocFunc() const
2087 : {
2088 0 : return pDocShell->GetDocFunc();
2089 : }
2090 :
2091 10565 : SfxBindings& ScViewData::GetBindings()
2092 : {
2093 : OSL_ENSURE( pViewShell, "GetBindings() without ViewShell" );
2094 10565 : return pViewShell->GetViewFrame()->GetBindings();
2095 : }
2096 :
2097 434 : SfxDispatcher& ScViewData::GetDispatcher()
2098 : {
2099 : OSL_ENSURE( pViewShell, "GetDispatcher() without ViewShell" );
2100 434 : return *pViewShell->GetViewFrame()->GetDispatcher();
2101 : }
2102 :
2103 41689 : ScMarkData& ScViewData::GetMarkData()
2104 : {
2105 41689 : return *mpMarkData;
2106 : }
2107 :
2108 42 : const ScMarkData& ScViewData::GetMarkData() const
2109 : {
2110 42 : return *mpMarkData;
2111 : }
2112 :
2113 0 : vcl::Window* ScViewData::GetDialogParent()
2114 : {
2115 : OSL_ENSURE( pViewShell, "GetDialogParent() ohne ViewShell" );
2116 0 : return pViewShell->GetDialogParent();
2117 : }
2118 :
2119 1013 : ScGridWindow* ScViewData::GetActiveWin()
2120 : {
2121 : OSL_ENSURE( pView, "GetActiveWin() ohne View" );
2122 1013 : return pView->GetActiveWin();
2123 : }
2124 :
2125 0 : const ScGridWindow* ScViewData::GetActiveWin() const
2126 : {
2127 : OSL_ENSURE( pView, "GetActiveWin() ohne View" );
2128 0 : return pView->GetActiveWin();
2129 : }
2130 :
2131 696 : ScDrawView* ScViewData::GetScDrawView()
2132 : {
2133 : OSL_ENSURE( pView, "GetScDrawView() ohne View" );
2134 696 : return pView->GetScDrawView();
2135 : }
2136 :
2137 2964 : bool ScViewData::IsMinimized()
2138 : {
2139 : OSL_ENSURE( pView, "IsMinimized() ohne View" );
2140 2964 : return pView->IsMinimized();
2141 : }
2142 :
2143 0 : void ScViewData::UpdateScreenZoom( const Fraction& rNewX, const Fraction& rNewY )
2144 : {
2145 0 : Fraction aOldX = GetZoomX();
2146 0 : Fraction aOldY = GetZoomY();
2147 :
2148 0 : SetZoom( rNewX, rNewY, false );
2149 :
2150 0 : Fraction aWidth = GetZoomX();
2151 0 : aWidth *= Fraction( aScrSize.Width(),1 );
2152 0 : aWidth /= aOldX;
2153 :
2154 0 : Fraction aHeight = GetZoomY();
2155 0 : aHeight *= Fraction( aScrSize.Height(),1 );
2156 0 : aHeight /= aOldY;
2157 :
2158 0 : aScrSize.Width() = (long) aWidth;
2159 0 : aScrSize.Height() = (long) aHeight;
2160 0 : }
2161 :
2162 2338 : void ScViewData::CalcPPT()
2163 : {
2164 2338 : nPPTX = ScGlobal::nScreenPPTX * (double) GetZoomX();
2165 2338 : if (pDocShell)
2166 2338 : nPPTX = nPPTX / pDocShell->GetOutputFactor(); // Faktor ist Drucker zu Bildschirm
2167 2338 : nPPTY = ScGlobal::nScreenPPTY * (double) GetZoomY();
2168 :
2169 : // if detective objects are present,
2170 : // try to adjust horizontal scale so the most common column width has minimal rounding errors,
2171 : // to avoid differences between cell and drawing layer output
2172 :
2173 2338 : if ( pDoc && pDoc->HasDetectiveObjects(nTabNo) )
2174 : {
2175 0 : SCCOL nEndCol = 0;
2176 0 : SCROW nDummy = 0;
2177 0 : pDoc->GetTableArea( nTabNo, nEndCol, nDummy );
2178 0 : if (nEndCol<20)
2179 0 : nEndCol = 20; // same end position as when determining draw scale
2180 :
2181 0 : sal_uInt16 nTwips = pDoc->GetCommonWidth( nEndCol, nTabNo );
2182 0 : if ( nTwips )
2183 : {
2184 0 : double fOriginal = nTwips * nPPTX;
2185 0 : if ( fOriginal < static_cast<double>(nEndCol) )
2186 : {
2187 : // if one column is smaller than the column count,
2188 : // rounding errors are likely to add up to a whole column.
2189 :
2190 0 : double fRounded = ::rtl::math::approxFloor( fOriginal + 0.5 );
2191 0 : if ( fRounded > 0.0 )
2192 : {
2193 0 : double fScale = fRounded / fOriginal + 1E-6;
2194 0 : if ( fScale >= 0.9 && fScale <= 1.1 )
2195 0 : nPPTX *= fScale;
2196 : }
2197 : }
2198 : }
2199 : }
2200 2338 : }
2201 :
2202 : #define SC_OLD_TABSEP '/'
2203 : #define SC_NEW_TABSEP '+'
2204 :
2205 1 : void ScViewData::WriteUserData(OUString& rData)
2206 : {
2207 : // nZoom (bis 364v) oder nZoom/nPageZoom/bPageMode (ab 364w)
2208 : // nTab
2209 : // Tab-ControlBreite
2210 : // pro Tabelle:
2211 : // CursorX/CursorY/HSplitMode/VSplitMode/HSplitPos/VSplitPos/SplitActive/
2212 : // PosX[links]/PosX[rechts]/PosY[oben]/PosY[unten]
2213 : // wenn Zeilen groesser 8192, "+" statt "/"
2214 :
2215 1 : sal_uInt16 nZoom = (sal_uInt16)((pThisTab->aZoomY.GetNumerator() * 100) / pThisTab->aZoomY.GetDenominator());
2216 1 : rData = OUString::number( nZoom ) + "/";
2217 1 : nZoom = (sal_uInt16)((pThisTab->aPageZoomY.GetNumerator() * 100) / pThisTab->aPageZoomY.GetDenominator());
2218 1 : rData += OUString::number( nZoom ) + "/";
2219 1 : if (bPagebreak)
2220 0 : rData += "1";
2221 : else
2222 1 : rData += "0";
2223 :
2224 2 : rData += ";" + OUString::number( nTabNo ) + ";" TAG_TABBARWIDTH +
2225 3 : OUString::number( pView->GetTabBarWidth() );
2226 :
2227 1 : SCTAB nTabCount = pDoc->GetTableCount();
2228 2 : for (SCTAB i=0; i<nTabCount; i++)
2229 : {
2230 1 : rData += ";"; // Numerierung darf auf keinen Fall durcheinanderkommen
2231 1 : if (i < static_cast<SCTAB>(maTabData.size()) && maTabData[i])
2232 : {
2233 1 : OUString cTabSep = OUString(SC_OLD_TABSEP); // like 3.1
2234 3 : if ( maTabData[i]->nCurY > MAXROW_30 ||
2235 3 : maTabData[i]->nPosY[0] > MAXROW_30 || maTabData[i]->nPosY[1] > MAXROW_30 ||
2236 1 : ( maTabData[i]->eVSplitMode == SC_SPLIT_FIX &&
2237 0 : maTabData[i]->nFixPosY > MAXROW_30 ) )
2238 : {
2239 0 : cTabSep = OUStringLiteral1<SC_NEW_TABSEP>(); // in order to not kill a 3.1-version
2240 : }
2241 :
2242 2 : rData += OUString::number( maTabData[i]->nCurX ) + cTabSep +
2243 4 : OUString::number( maTabData[i]->nCurY ) + cTabSep +
2244 4 : OUString::number( maTabData[i]->eHSplitMode ) + cTabSep +
2245 3 : OUString::number( maTabData[i]->eVSplitMode ) + cTabSep;
2246 1 : if ( maTabData[i]->eHSplitMode == SC_SPLIT_FIX )
2247 0 : rData += OUString::number( maTabData[i]->nFixPosX );
2248 : else
2249 1 : rData += OUString::number( maTabData[i]->nHSplitPos );
2250 1 : rData += cTabSep;
2251 1 : if ( maTabData[i]->eVSplitMode == SC_SPLIT_FIX )
2252 0 : rData += OUString::number( maTabData[i]->nFixPosY );
2253 : else
2254 1 : rData += OUString::number( maTabData[i]->nVSplitPos );
2255 2 : rData += cTabSep +
2256 4 : OUString::number( maTabData[i]->eWhichActive ) + cTabSep +
2257 4 : OUString::number( maTabData[i]->nPosX[0] ) + cTabSep +
2258 4 : OUString::number( maTabData[i]->nPosX[1] ) + cTabSep +
2259 4 : OUString::number( maTabData[i]->nPosY[0] ) + cTabSep +
2260 3 : OUString::number( maTabData[i]->nPosY[1] );
2261 : }
2262 : }
2263 1 : }
2264 :
2265 0 : void ScViewData::ReadUserData(const OUString& rData)
2266 : {
2267 0 : if (rData.isEmpty()) // Leerer String kommt bei "neu Laden"
2268 0 : return; // then exit without assertion
2269 :
2270 0 : sal_Int32 nCount = comphelper::string::getTokenCount(rData, ';');
2271 0 : if ( nCount <= 2 )
2272 : {
2273 : // beim Reload in der Seitenansicht sind evtl. die Preview-UserData
2274 : // stehengelassen worden. Den Zoom von der Preview will man hier nicht...
2275 : OSL_FAIL("ReadUserData: das sind nicht meine Daten");
2276 0 : return;
2277 : }
2278 :
2279 : // nicht pro Tabelle:
2280 0 : SCTAB nTabStart = 2;
2281 :
2282 0 : Fraction aZoomX, aZoomY, aPageZoomX, aPageZoomY; // evaluate (all sheets?)
2283 :
2284 0 : OUString aZoomStr = rData.getToken(0, ';'); // Zoom/PageZoom/Modus
2285 0 : sal_uInt16 nNormZoom = sal::static_int_cast<sal_uInt16>(aZoomStr.getToken(0,'/').toInt32());
2286 0 : if ( nNormZoom >= MINZOOM && nNormZoom <= MAXZOOM )
2287 0 : aZoomX = aZoomY = Fraction( nNormZoom, 100 ); // "normal" zoom (always)
2288 0 : sal_uInt16 nPageZoom = sal::static_int_cast<sal_uInt16>(aZoomStr.getToken(1,'/').toInt32());
2289 0 : if ( nPageZoom >= MINZOOM && nPageZoom <= MAXZOOM )
2290 0 : aPageZoomX = aPageZoomY = Fraction( nPageZoom, 100 ); // Pagebreak-zoom, if set
2291 0 : sal_Unicode cMode = aZoomStr.getToken(2,'/')[0]; // 0 or "0"/"1"
2292 0 : SetPagebreakMode( cMode == '1' );
2293 : // SetPagebreakMode muss immer gerufen werden wegen CalcPPT / RecalcPixPos()
2294 :
2295 : // Tabelle kann ungueltig geworden sein (z.B. letzte Version):
2296 0 : SCTAB nNewTab = static_cast<SCTAB>(rData.getToken(1, ';').toInt32());
2297 0 : if (pDoc->HasTable( nNewTab ))
2298 0 : SetTabNo(nNewTab);
2299 :
2300 : // wenn vorhanden, TabBar-Breite holen:
2301 0 : OUString aTabOpt = rData.getToken(2, ';');
2302 :
2303 0 : if (aTabOpt.startsWith(TAG_TABBARWIDTH))
2304 : {
2305 0 : sal_Int32 nTagLen = RTL_CONSTASCII_LENGTH(TAG_TABBARWIDTH);
2306 0 : pView->SetTabBarWidth(aTabOpt.copy(nTagLen).toInt32());
2307 0 : nTabStart = 3;
2308 : }
2309 :
2310 : // per table
2311 0 : SCTAB nPos = 0;
2312 0 : while ( nCount > nPos+nTabStart )
2313 : {
2314 0 : aTabOpt = rData.getToken(static_cast<sal_Int32>(nPos+nTabStart), ';');
2315 0 : EnsureTabDataSize(nPos + 1);
2316 0 : if (!maTabData[nPos])
2317 0 : maTabData[nPos] = new ScViewDataTable;
2318 :
2319 0 : sal_Unicode cTabSep = 0;
2320 0 : if (comphelper::string::getTokenCount(aTabOpt, SC_OLD_TABSEP) >= 11)
2321 0 : cTabSep = SC_OLD_TABSEP;
2322 0 : else if (comphelper::string::getTokenCount(aTabOpt, SC_NEW_TABSEP) >= 11)
2323 0 : cTabSep = SC_NEW_TABSEP;
2324 : // '+' ist nur erlaubt, wenn wir mit Zeilen > 8192 umgehen koennen
2325 :
2326 0 : if (cTabSep)
2327 : {
2328 0 : maTabData[nPos]->nCurX = SanitizeCol( static_cast<SCCOL>(aTabOpt.getToken(0,cTabSep).toInt32()));
2329 0 : maTabData[nPos]->nCurY = SanitizeRow( aTabOpt.getToken(1,cTabSep).toInt32());
2330 0 : maTabData[nPos]->eHSplitMode = (ScSplitMode) aTabOpt.getToken(2,cTabSep).toInt32();
2331 0 : maTabData[nPos]->eVSplitMode = (ScSplitMode) aTabOpt.getToken(3,cTabSep).toInt32();
2332 :
2333 0 : if ( maTabData[nPos]->eHSplitMode == SC_SPLIT_FIX )
2334 : {
2335 0 : maTabData[nPos]->nFixPosX = SanitizeCol( static_cast<SCCOL>(aTabOpt.getToken(4,cTabSep).toInt32()));
2336 0 : UpdateFixX(nPos);
2337 : }
2338 : else
2339 0 : maTabData[nPos]->nHSplitPos = aTabOpt.getToken(4,cTabSep).toInt32();
2340 :
2341 0 : if ( maTabData[nPos]->eVSplitMode == SC_SPLIT_FIX )
2342 : {
2343 0 : maTabData[nPos]->nFixPosY = SanitizeRow( aTabOpt.getToken(5,cTabSep).toInt32());
2344 0 : UpdateFixY(nPos);
2345 : }
2346 : else
2347 0 : maTabData[nPos]->nVSplitPos = aTabOpt.getToken(5,cTabSep).toInt32();
2348 :
2349 0 : maTabData[nPos]->eWhichActive = (ScSplitPos) aTabOpt.getToken(6,cTabSep).toInt32();
2350 0 : maTabData[nPos]->nPosX[0] = SanitizeCol( static_cast<SCCOL>(aTabOpt.getToken(7,cTabSep).toInt32()));
2351 0 : maTabData[nPos]->nPosX[1] = SanitizeCol( static_cast<SCCOL>(aTabOpt.getToken(8,cTabSep).toInt32()));
2352 0 : maTabData[nPos]->nPosY[0] = SanitizeRow( aTabOpt.getToken(9,cTabSep).toInt32());
2353 0 : maTabData[nPos]->nPosY[1] = SanitizeRow( aTabOpt.getToken(10,cTabSep).toInt32());
2354 :
2355 : // Test, ob der aktive Teil laut SplitMode ueberhaupt existiert
2356 : // (Bug #44516#)
2357 0 : ScSplitPos eTest = maTabData[nPos]->eWhichActive;
2358 0 : if ( ( WhichH( eTest ) == SC_SPLIT_RIGHT &&
2359 0 : maTabData[nPos]->eHSplitMode == SC_SPLIT_NONE ) ||
2360 0 : ( WhichV( eTest ) == SC_SPLIT_TOP &&
2361 0 : maTabData[nPos]->eVSplitMode == SC_SPLIT_NONE ) )
2362 : {
2363 : // dann wieder auf Default (unten links)
2364 0 : maTabData[nPos]->eWhichActive = SC_SPLIT_BOTTOMLEFT;
2365 : OSL_FAIL("SplitPos musste korrigiert werden");
2366 : }
2367 : }
2368 0 : ++nPos;
2369 : }
2370 :
2371 0 : RecalcPixPos();
2372 : }
2373 :
2374 25 : void ScViewData::WriteExtOptions( ScExtDocOptions& rDocOpt ) const
2375 : {
2376 : // *** Fill extended document data for export filters ***
2377 :
2378 : // document settings
2379 25 : ScExtDocSettings& rDocSett = rDocOpt.GetDocSettings();
2380 :
2381 : // displayed sheet
2382 25 : rDocSett.mnDisplTab = GetTabNo();
2383 :
2384 : // width of the tabbar, relative to frame window width
2385 25 : rDocSett.mfTabBarWidth = pView->GetPendingRelTabBarWidth();
2386 25 : if( rDocSett.mfTabBarWidth < 0.0 )
2387 25 : rDocSett.mfTabBarWidth = pView->GetRelTabBarWidth();
2388 :
2389 : // sheet settings
2390 82 : for( SCTAB nTab = 0; nTab < static_cast<SCTAB>(maTabData.size()); ++nTab )
2391 : {
2392 57 : if( const ScViewDataTable* pViewTab = maTabData[ nTab ] )
2393 : {
2394 32 : ScExtTabSettings& rTabSett = rDocOpt.GetOrCreateTabSettings( nTab );
2395 :
2396 : // split mode
2397 32 : ScSplitMode eHSplit = pViewTab->eHSplitMode;
2398 32 : ScSplitMode eVSplit = pViewTab->eVSplitMode;
2399 32 : bool bHSplit = eHSplit != SC_SPLIT_NONE;
2400 32 : bool bVSplit = eVSplit != SC_SPLIT_NONE;
2401 32 : bool bRealSplit = (eHSplit == SC_SPLIT_NORMAL) || (eVSplit == SC_SPLIT_NORMAL);
2402 32 : bool bFrozen = (eHSplit == SC_SPLIT_FIX) || (eVSplit == SC_SPLIT_FIX);
2403 : OSL_ENSURE( !bRealSplit || !bFrozen, "ScViewData::WriteExtOptions - split and freeze in same sheet" );
2404 32 : rTabSett.mbFrozenPanes = !bRealSplit && bFrozen;
2405 :
2406 : // split and freeze position
2407 32 : rTabSett.maSplitPos = Point( 0, 0 );
2408 32 : rTabSett.maFreezePos.Set( 0, 0, nTab );
2409 32 : if( bRealSplit )
2410 : {
2411 0 : Point& rSplitPos = rTabSett.maSplitPos;
2412 0 : rSplitPos = Point( bHSplit ? pViewTab->nHSplitPos : 0, bVSplit ? pViewTab->nVSplitPos : 0 );
2413 0 : rSplitPos = Application::GetDefaultDevice()->PixelToLogic( rSplitPos, MapMode( MAP_TWIP ) );
2414 0 : if( pDocShell )
2415 0 : rSplitPos.X() = (long)((double)rSplitPos.X() / pDocShell->GetOutputFactor());
2416 : }
2417 32 : else if( bFrozen )
2418 : {
2419 0 : if( bHSplit ) rTabSett.maFreezePos.SetCol( pViewTab->nFixPosX );
2420 0 : if( bVSplit ) rTabSett.maFreezePos.SetRow( pViewTab->nFixPosY );
2421 : }
2422 :
2423 : // first visible cell in top-left and additional panes
2424 32 : rTabSett.maFirstVis.Set( pViewTab->nPosX[ SC_SPLIT_LEFT ], pViewTab->nPosY[ bVSplit ? SC_SPLIT_TOP : SC_SPLIT_BOTTOM ], nTab );
2425 32 : rTabSett.maSecondVis.Set( pViewTab->nPosX[ SC_SPLIT_RIGHT ], pViewTab->nPosY[ SC_SPLIT_BOTTOM ], nTab );
2426 :
2427 : // active pane
2428 32 : switch( pViewTab->eWhichActive )
2429 : {
2430 : // no horizontal split -> always use left panes
2431 : // no vertical split -> always use top panes
2432 : case SC_SPLIT_TOPLEFT:
2433 0 : rTabSett.meActivePane = SCEXT_PANE_TOPLEFT;
2434 0 : break;
2435 : case SC_SPLIT_TOPRIGHT:
2436 0 : rTabSett.meActivePane = bHSplit ? SCEXT_PANE_TOPRIGHT : SCEXT_PANE_TOPLEFT;
2437 0 : break;
2438 : case SC_SPLIT_BOTTOMLEFT:
2439 32 : rTabSett.meActivePane = bVSplit ? SCEXT_PANE_BOTTOMLEFT : SCEXT_PANE_TOPLEFT;
2440 32 : break;
2441 : case SC_SPLIT_BOTTOMRIGHT:
2442 : rTabSett.meActivePane = bHSplit ?
2443 : (bVSplit ? SCEXT_PANE_BOTTOMRIGHT : SCEXT_PANE_TOPRIGHT) :
2444 0 : (bVSplit ? SCEXT_PANE_BOTTOMLEFT : SCEXT_PANE_TOPLEFT);
2445 0 : break;
2446 : }
2447 :
2448 : // cursor position
2449 32 : rTabSett.maCursor.Set( pViewTab->nCurX, pViewTab->nCurY, nTab );
2450 :
2451 : // sheet selection and selected ranges
2452 32 : const ScMarkData& rMarkData = GetMarkData();
2453 32 : rTabSett.mbSelected = rMarkData.GetTableSelect( nTab );
2454 32 : rMarkData.FillRangeListWithMarks( &rTabSett.maSelection, true );
2455 :
2456 : // grid color
2457 32 : rTabSett.maGridColor.SetColor( COL_AUTO );
2458 32 : if( pOptions )
2459 : {
2460 32 : const Color& rGridColor = pOptions->GetGridColor();
2461 32 : if( rGridColor.GetColor() != SC_STD_GRIDCOLOR )
2462 0 : rTabSett.maGridColor = rGridColor;
2463 : }
2464 32 : rTabSett.mbShowGrid = pViewTab->bShowGrid;
2465 :
2466 : // view mode and zoom
2467 32 : rTabSett.mbPageMode = bPagebreak;
2468 32 : rTabSett.mnNormalZoom = static_cast< long >( pViewTab->aZoomY * Fraction( 100.0 ) );
2469 32 : rTabSett.mnPageZoom = static_cast< long >( pViewTab->aPageZoomY * Fraction( 100.0 ) );
2470 : }
2471 : }
2472 25 : }
2473 :
2474 29 : void ScViewData::ReadExtOptions( const ScExtDocOptions& rDocOpt )
2475 : {
2476 : // *** Get extended document data from import filters ***
2477 :
2478 58 : if( !rDocOpt.IsChanged() ) return;
2479 :
2480 : // document settings
2481 29 : const ScExtDocSettings& rDocSett = rDocOpt.GetDocSettings();
2482 :
2483 : // displayed sheet
2484 29 : SetTabNo( rDocSett.mnDisplTab );
2485 :
2486 : /* Width of the tabbar, relative to frame window width. We do not have the
2487 : correct width of the frame window here -> store in ScTabView, which sets
2488 : the size in the next resize. */
2489 29 : pView->SetPendingRelTabBarWidth( rDocSett.mfTabBarWidth );
2490 :
2491 : // sheet settings
2492 29 : SCTAB nLastTab = rDocOpt.GetLastTab();
2493 29 : if (static_cast<SCTAB>(maTabData.size()) <= nLastTab)
2494 24 : maTabData.resize(nLastTab+1);
2495 :
2496 116 : for( SCTAB nTab = 0; nTab < static_cast<SCTAB>(maTabData.size()); ++nTab )
2497 : {
2498 87 : if( const ScExtTabSettings* pTabSett = rDocOpt.GetTabSettings( nTab ) )
2499 : {
2500 85 : if( !maTabData[ nTab ] )
2501 55 : maTabData[ nTab ] = new ScViewDataTable;
2502 :
2503 85 : const ScExtTabSettings& rTabSett = *pTabSett;
2504 85 : ScViewDataTable& rViewTab = *maTabData[ nTab ];
2505 :
2506 : // split mode initialization
2507 85 : bool bFrozen = rTabSett.mbFrozenPanes;
2508 85 : bool bHSplit = bFrozen ? (rTabSett.maFreezePos.Col() > 0) : (rTabSett.maSplitPos.X() > 0);
2509 85 : bool bVSplit = bFrozen ? (rTabSett.maFreezePos.Row() > 0) : (rTabSett.maSplitPos.Y() > 0);
2510 :
2511 : // first visible cell of top-left pane and additional panes
2512 85 : if (rTabSett.maFirstVis.IsValid())
2513 : {
2514 85 : rViewTab.nPosX[ SC_SPLIT_LEFT ] = rTabSett.maFirstVis.Col();
2515 85 : rViewTab.nPosY[ bVSplit ? SC_SPLIT_TOP : SC_SPLIT_BOTTOM ] = rTabSett.maFirstVis.Row();
2516 : }
2517 :
2518 85 : if (rTabSett.maSecondVis.IsValid())
2519 : {
2520 85 : if (bHSplit)
2521 0 : rViewTab.nPosX[ SC_SPLIT_RIGHT ] = rTabSett.maSecondVis.Col();
2522 85 : if (bVSplit)
2523 0 : rViewTab.nPosY[ SC_SPLIT_BOTTOM ] = rTabSett.maSecondVis.Row();
2524 : }
2525 :
2526 : // split mode, split and freeze position
2527 85 : rViewTab.eHSplitMode = rViewTab.eVSplitMode = SC_SPLIT_NONE;
2528 85 : rViewTab.nHSplitPos = rViewTab.nVSplitPos = 0;
2529 85 : rViewTab.nFixPosX = 0;
2530 85 : rViewTab.nFixPosY = 0;
2531 85 : if( bFrozen )
2532 : {
2533 0 : if( bHSplit )
2534 : {
2535 0 : rViewTab.eHSplitMode = SC_SPLIT_FIX;
2536 0 : rViewTab.nFixPosX = rTabSett.maFreezePos.Col();
2537 0 : UpdateFixX( nTab );
2538 : }
2539 0 : if( bVSplit )
2540 : {
2541 0 : rViewTab.eVSplitMode = SC_SPLIT_FIX;
2542 0 : rViewTab.nFixPosY = rTabSett.maFreezePos.Row();
2543 0 : UpdateFixY( nTab );
2544 : }
2545 : }
2546 : else
2547 : {
2548 : Point aPixel = Application::GetDefaultDevice()->LogicToPixel(
2549 85 : rTabSett.maSplitPos, MapMode( MAP_TWIP ) ); //! Zoom?
2550 : // the test for use of printer metrics for text formatting here
2551 : // effectively results in the nFactor = 1.0 regardless of the Option setting.
2552 85 : if( pDocShell && SC_MOD()->GetInputOptions().GetTextWysiwyg())
2553 : {
2554 0 : double nFactor = pDocShell->GetOutputFactor();
2555 0 : aPixel.X() = (long)( aPixel.X() * nFactor + 0.5 );
2556 : }
2557 :
2558 85 : bHSplit = bHSplit && aPixel.X() > 0;
2559 85 : bVSplit = bVSplit && aPixel.Y() > 0;
2560 85 : if( bHSplit )
2561 : {
2562 0 : rViewTab.eHSplitMode = SC_SPLIT_NORMAL;
2563 0 : rViewTab.nHSplitPos = aPixel.X();
2564 : }
2565 85 : if( bVSplit )
2566 : {
2567 0 : rViewTab.eVSplitMode = SC_SPLIT_NORMAL;
2568 0 : rViewTab.nVSplitPos = aPixel.Y();
2569 : }
2570 : }
2571 :
2572 : // active pane
2573 85 : ScSplitPos ePos = SC_SPLIT_BOTTOMLEFT;
2574 85 : switch( rTabSett.meActivePane )
2575 : {
2576 : // no horizontal split -> always use left panes
2577 : // no vertical split -> always use *bottom* panes
2578 : case SCEXT_PANE_TOPLEFT:
2579 85 : ePos = bVSplit ? SC_SPLIT_TOPLEFT : SC_SPLIT_BOTTOMLEFT;
2580 85 : break;
2581 : case SCEXT_PANE_TOPRIGHT:
2582 : ePos = bHSplit ?
2583 : (bVSplit ? SC_SPLIT_TOPRIGHT : SC_SPLIT_BOTTOMRIGHT) :
2584 0 : (bVSplit ? SC_SPLIT_TOPLEFT : SC_SPLIT_BOTTOMLEFT);
2585 0 : break;
2586 : case SCEXT_PANE_BOTTOMLEFT:
2587 0 : ePos = SC_SPLIT_BOTTOMLEFT;
2588 0 : break;
2589 : case SCEXT_PANE_BOTTOMRIGHT:
2590 0 : ePos = bHSplit ? SC_SPLIT_BOTTOMRIGHT : SC_SPLIT_BOTTOMLEFT;
2591 0 : break;
2592 : }
2593 85 : rViewTab.eWhichActive = ePos;
2594 :
2595 : // cursor position
2596 85 : const ScAddress& rCursor = rTabSett.maCursor;
2597 85 : if( rCursor.IsValid() )
2598 : {
2599 85 : rViewTab.nCurX = rCursor.Col();
2600 85 : rViewTab.nCurY = rCursor.Row();
2601 : }
2602 :
2603 : // sheet selection and selected ranges
2604 85 : ScMarkData& rMarkData = GetMarkData();
2605 85 : rMarkData.SelectTable( nTab, rTabSett.mbSelected );
2606 :
2607 : // zoom for each sheet
2608 85 : if( rTabSett.mnNormalZoom )
2609 85 : rViewTab.aZoomX = rViewTab.aZoomY = Fraction( rTabSett.mnNormalZoom, 100L );
2610 85 : if( rTabSett.mnPageZoom )
2611 85 : rViewTab.aPageZoomX = rViewTab.aPageZoomY = Fraction( rTabSett.mnPageZoom, 100L );
2612 :
2613 85 : rViewTab.bShowGrid = rTabSett.mbShowGrid;
2614 :
2615 : // get some settings from displayed Excel sheet, set at Calc document
2616 85 : if( nTab == GetTabNo() )
2617 : {
2618 : // grid color -- #i47435# set automatic grid color explicitly
2619 29 : if( pOptions )
2620 : {
2621 29 : Color aGridColor( rTabSett.maGridColor );
2622 29 : if( aGridColor.GetColor() == COL_AUTO )
2623 29 : aGridColor.SetColor( SC_STD_GRIDCOLOR );
2624 29 : pOptions->SetGridColor( aGridColor, EMPTY_OUSTRING );
2625 : }
2626 :
2627 : // view mode and default zoom (for new sheets) from current sheet
2628 29 : if( rTabSett.mnNormalZoom )
2629 29 : aDefZoomX = aDefZoomY = Fraction( rTabSett.mnNormalZoom, 100L );
2630 29 : if( rTabSett.mnPageZoom )
2631 29 : aDefPageZoomX = aDefPageZoomY = Fraction( rTabSett.mnPageZoom, 100L );
2632 : /* #i46820# set pagebreak mode via SetPagebreakMode(), this will
2633 : update map modes that are needed to draw text correctly. */
2634 29 : SetPagebreakMode( rTabSett.mbPageMode );
2635 : }
2636 : }
2637 : }
2638 :
2639 : // RecalcPixPos oder so - auch nMPos - auch bei ReadUserData ??!?!
2640 : }
2641 :
2642 236 : void ScViewData::WriteUserDataSequence(uno::Sequence <beans::PropertyValue>& rSettings) const
2643 : {
2644 236 : rSettings.realloc(SC_VIEWSETTINGS_COUNT);
2645 : // + 1, because we have to put the view id in the sequence
2646 236 : beans::PropertyValue* pSettings = rSettings.getArray();
2647 236 : if (pSettings)
2648 : {
2649 236 : sal_uInt16 nViewID(pViewShell->GetViewFrame()->GetCurViewId());
2650 236 : pSettings[SC_VIEW_ID].Name = SC_VIEWID;
2651 236 : OUStringBuffer sBuffer(SC_VIEW);
2652 : ::sax::Converter::convertNumber(sBuffer,
2653 236 : static_cast<sal_Int32>(nViewID));
2654 236 : pSettings[SC_VIEW_ID].Value <<= sBuffer.makeStringAndClear();
2655 :
2656 : uno::Reference<container::XNameContainer> xNameContainer =
2657 472 : document::NamedPropertyValues::create( comphelper::getProcessComponentContext() );
2658 551 : for (SCTAB nTab=0; nTab<static_cast<SCTAB>(maTabData.size()); nTab++)
2659 : {
2660 315 : if (maTabData[nTab])
2661 : {
2662 292 : uno::Sequence <beans::PropertyValue> aTableViewSettings;
2663 292 : maTabData[nTab]->WriteUserDataSequence(aTableViewSettings, *this, nTab);
2664 584 : OUString sTabName;
2665 292 : GetDocument()->GetName( nTab, sTabName );
2666 584 : uno::Any aAny;
2667 292 : aAny <<= aTableViewSettings;
2668 : try
2669 : {
2670 292 : xNameContainer->insertByName(sTabName, aAny);
2671 : }
2672 : //#101739#; two tables with the same name are possible
2673 0 : catch ( container::ElementExistException& )
2674 : {
2675 : OSL_FAIL("seems there are two tables with the same name");
2676 : }
2677 0 : catch ( uno::RuntimeException& )
2678 : {
2679 : OSL_FAIL("something went wrong");
2680 292 : }
2681 : }
2682 : }
2683 236 : pSettings[SC_TABLE_VIEWSETTINGS].Name = SC_TABLES;
2684 236 : pSettings[SC_TABLE_VIEWSETTINGS].Value <<= xNameContainer;
2685 :
2686 472 : OUString sName;
2687 236 : GetDocument()->GetName( nTabNo, sName );
2688 236 : pSettings[SC_ACTIVE_TABLE].Name = SC_ACTIVETABLE;
2689 236 : pSettings[SC_ACTIVE_TABLE].Value <<= sName;
2690 236 : pSettings[SC_HORIZONTAL_SCROLL_BAR_WIDTH].Name = SC_HORIZONTALSCROLLBARWIDTH;
2691 236 : pSettings[SC_HORIZONTAL_SCROLL_BAR_WIDTH].Value <<= sal_Int32(pView->GetTabBarWidth());
2692 236 : sal_Int32 nZoomValue ((pThisTab->aZoomY.GetNumerator() * 100) / pThisTab->aZoomY.GetDenominator());
2693 236 : sal_Int32 nPageZoomValue ((pThisTab->aPageZoomY.GetNumerator() * 100) / pThisTab->aPageZoomY.GetDenominator());
2694 236 : pSettings[SC_ZOOM_TYPE].Name = SC_ZOOMTYPE;
2695 236 : pSettings[SC_ZOOM_TYPE].Value <<= sal_Int16(pThisTab->eZoomType);
2696 236 : pSettings[SC_ZOOM_VALUE].Name = SC_ZOOMVALUE;
2697 236 : pSettings[SC_ZOOM_VALUE].Value <<= nZoomValue;
2698 236 : pSettings[SC_PAGE_VIEW_ZOOM_VALUE].Name = SC_PAGEVIEWZOOMVALUE;
2699 236 : pSettings[SC_PAGE_VIEW_ZOOM_VALUE].Value <<= nPageZoomValue;
2700 236 : pSettings[SC_PAGE_BREAK_PREVIEW].Name = SC_SHOWPAGEBREAKPREVIEW;
2701 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_PAGE_BREAK_PREVIEW].Value, bPagebreak);
2702 :
2703 236 : if (pOptions)
2704 : {
2705 236 : pSettings[SC_SHOWZERO].Name = SC_UNO_SHOWZERO;
2706 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_SHOWZERO].Value, pOptions->GetOption( VOPT_NULLVALS ) );
2707 236 : pSettings[SC_SHOWNOTES].Name = SC_UNO_SHOWNOTES;
2708 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_SHOWNOTES].Value, pOptions->GetOption( VOPT_NOTES ) );
2709 236 : pSettings[SC_SHOWGRID].Name = SC_UNO_SHOWGRID;
2710 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_SHOWGRID].Value, pOptions->GetOption( VOPT_GRID ) );
2711 236 : pSettings[SC_GRIDCOLOR].Name = SC_UNO_GRIDCOLOR;
2712 236 : OUString aColorName;
2713 236 : Color aColor = pOptions->GetGridColor(&aColorName);
2714 236 : pSettings[SC_GRIDCOLOR].Value <<= static_cast<sal_Int64>(aColor.GetColor());
2715 236 : pSettings[SC_SHOWPAGEBR].Name = SC_UNO_SHOWPAGEBR;
2716 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_SHOWPAGEBR].Value, pOptions->GetOption( VOPT_PAGEBREAKS ) );
2717 236 : pSettings[SC_COLROWHDR].Name = SC_UNO_COLROWHDR;
2718 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_COLROWHDR].Value, pOptions->GetOption( VOPT_HEADER ) );
2719 236 : pSettings[SC_SHEETTABS].Name = SC_UNO_SHEETTABS;
2720 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_SHEETTABS].Value, pOptions->GetOption( VOPT_TABCONTROLS ) );
2721 236 : pSettings[SC_OUTLSYMB].Name = SC_UNO_OUTLSYMB;
2722 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_OUTLSYMB].Value, pOptions->GetOption( VOPT_OUTLINER ) );
2723 236 : pSettings[SC_VALUE_HIGHLIGHTING].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( SC_UNO_VALUEHIGH ) );
2724 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_VALUE_HIGHLIGHTING].Value, pOptions->GetOption( VOPT_SYNTAX ) );
2725 :
2726 236 : const ScGridOptions& aGridOpt = pOptions->GetGridOptions();
2727 236 : pSettings[SC_SNAPTORASTER].Name = SC_UNO_SNAPTORASTER;
2728 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_SNAPTORASTER].Value, aGridOpt.GetUseGridSnap() );
2729 236 : pSettings[SC_RASTERVIS].Name = SC_UNO_RASTERVIS;
2730 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_RASTERVIS].Value, aGridOpt.GetGridVisible() );
2731 236 : pSettings[SC_RASTERRESX].Name = SC_UNO_RASTERRESX;
2732 236 : pSettings[SC_RASTERRESX].Value <<= static_cast<sal_Int32> ( aGridOpt.GetFieldDrawX() );
2733 236 : pSettings[SC_RASTERRESY].Name = SC_UNO_RASTERRESY;
2734 236 : pSettings[SC_RASTERRESY].Value <<= static_cast<sal_Int32> ( aGridOpt.GetFieldDrawY() );
2735 236 : pSettings[SC_RASTERSUBX].Name = SC_UNO_RASTERSUBX;
2736 236 : pSettings[SC_RASTERSUBX].Value <<= static_cast<sal_Int32> ( aGridOpt.GetFieldDivisionX() );
2737 236 : pSettings[SC_RASTERSUBY].Name = SC_UNO_RASTERSUBY;
2738 236 : pSettings[SC_RASTERSUBY].Value <<= static_cast<sal_Int32> ( aGridOpt.GetFieldDivisionY() );
2739 236 : pSettings[SC_RASTERSYNC].Name = SC_UNO_RASTERSYNC;
2740 236 : ScUnoHelpFunctions::SetBoolInAny( pSettings[SC_RASTERSYNC].Value, aGridOpt.GetSynchronize() );
2741 236 : }
2742 : }
2743 236 : }
2744 :
2745 347 : void ScViewData::ReadUserDataSequence(const uno::Sequence <beans::PropertyValue>& rSettings)
2746 : {
2747 347 : std::vector<bool> aHasZoomVect( GetDocument()->GetTableCount(), false );
2748 :
2749 347 : sal_Int32 nCount(rSettings.getLength());
2750 347 : sal_Int32 nTemp32(0);
2751 347 : sal_Int16 nTemp16(0);
2752 347 : bool bPageMode(false);
2753 :
2754 347 : EnsureTabDataSize(GetDocument()->GetTableCount()-1);
2755 :
2756 8077 : for (sal_Int32 i = 0; i < nCount; i++)
2757 : {
2758 : // SC_VIEWID has to parse and use by mba
2759 7730 : OUString sName(rSettings[i].Name);
2760 7730 : if (sName == SC_TABLES)
2761 : {
2762 347 : uno::Reference<container::XNameContainer> xNameContainer;
2763 347 : if ((rSettings[i].Value >>= xNameContainer) && xNameContainer->hasElements())
2764 : {
2765 347 : uno::Sequence< OUString > aNames(xNameContainer->getElementNames());
2766 818 : for (sal_Int32 nTabPos = 0; nTabPos < aNames.getLength(); nTabPos++)
2767 : {
2768 471 : OUString sTabName(aNames[nTabPos]);
2769 471 : SCTAB nTab(0);
2770 471 : if (GetDocument()->GetTable(sTabName, nTab))
2771 : {
2772 471 : uno::Any aAny = xNameContainer->getByName(aNames[nTabPos]);
2773 942 : uno::Sequence<beans::PropertyValue> aTabSettings;
2774 471 : if (aAny >>= aTabSettings)
2775 : {
2776 471 : EnsureTabDataSize(nTab + 1);
2777 471 : if (!maTabData[nTab])
2778 68 : maTabData[nTab] = new ScViewDataTable;
2779 :
2780 471 : bool bHasZoom = false;
2781 471 : maTabData[nTab]->ReadUserDataSequence(aTabSettings, *this, nTab, bHasZoom);
2782 471 : aHasZoomVect[nTab] = bHasZoom;
2783 471 : }
2784 : }
2785 818 : }
2786 347 : }
2787 : }
2788 7383 : else if (sName == SC_ACTIVETABLE)
2789 : {
2790 347 : OUString sValue;
2791 347 : if(rSettings[i].Value >>= sValue)
2792 : {
2793 347 : OUString sTabName(sValue);
2794 347 : SCTAB nTab(0);
2795 347 : if (GetDocument()->GetTable(sTabName, nTab))
2796 347 : nTabNo = nTab;
2797 347 : }
2798 : }
2799 7036 : else if (sName == SC_HORIZONTALSCROLLBARWIDTH)
2800 : {
2801 279 : if (rSettings[i].Value >>= nTemp32)
2802 279 : pView->SetTabBarWidth(nTemp32);
2803 : }
2804 6757 : else if (sName == SC_RELHORIZONTALTABBARWIDTH)
2805 : {
2806 68 : double fWidth = 0.0;
2807 68 : if (rSettings[i].Value >>= fWidth)
2808 68 : pView->SetPendingRelTabBarWidth( fWidth );
2809 : }
2810 6689 : else if (sName == SC_ZOOMTYPE)
2811 : {
2812 279 : if (rSettings[i].Value >>= nTemp16)
2813 279 : eDefZoomType = SvxZoomType(nTemp16);
2814 : }
2815 6410 : else if (sName == SC_ZOOMVALUE)
2816 : {
2817 279 : if (rSettings[i].Value >>= nTemp32)
2818 : {
2819 279 : Fraction aZoom(nTemp32, 100);
2820 279 : aDefZoomX = aDefZoomY = aZoom;
2821 : }
2822 : }
2823 6131 : else if (sName == SC_PAGEVIEWZOOMVALUE)
2824 : {
2825 279 : if (rSettings[i].Value >>= nTemp32)
2826 : {
2827 279 : Fraction aZoom(nTemp32, 100);
2828 279 : aDefPageZoomX = aDefPageZoomY = aZoom;
2829 : }
2830 : }
2831 5852 : else if (sName == SC_SHOWPAGEBREAKPREVIEW)
2832 347 : bPageMode = ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value );
2833 5505 : else if ( sName == SC_UNO_SHOWZERO )
2834 347 : pOptions->SetOption(VOPT_NULLVALS, ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value ) );
2835 5158 : else if ( sName == SC_UNO_SHOWNOTES )
2836 279 : pOptions->SetOption(VOPT_NOTES, ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value ) );
2837 4879 : else if ( sName == SC_UNO_SHOWGRID )
2838 347 : pOptions->SetOption(VOPT_GRID, ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value ) );
2839 4532 : else if ( sName == SC_UNO_GRIDCOLOR )
2840 : {
2841 347 : sal_Int64 nColor = 0;
2842 347 : if (rSettings[i].Value >>= nColor)
2843 : {
2844 347 : OUString aColorName;
2845 347 : Color aColor(static_cast<sal_uInt32>(nColor));
2846 : // #i47435# set automatic grid color explicitly
2847 347 : if( aColor.GetColor() == COL_AUTO )
2848 68 : aColor.SetColor( SC_STD_GRIDCOLOR );
2849 347 : pOptions->SetGridColor(aColor, aColorName);
2850 : }
2851 : }
2852 4185 : else if ( sName == SC_UNO_SHOWPAGEBR )
2853 279 : pOptions->SetOption(VOPT_PAGEBREAKS, ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value ) );
2854 3906 : else if ( sName == SC_UNO_COLROWHDR )
2855 347 : pOptions->SetOption(VOPT_HEADER, ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value ) );
2856 3559 : else if ( sName == SC_UNO_SHEETTABS )
2857 347 : pOptions->SetOption(VOPT_TABCONTROLS, ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value ) );
2858 3212 : else if ( sName == SC_UNO_OUTLSYMB )
2859 347 : pOptions->SetOption(VOPT_OUTLINER, ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value ) );
2860 2865 : else if ( sName == SC_UNO_SHOWOBJ )
2861 : {
2862 : // #i80528# placeholders not supported anymore
2863 68 : if ( rSettings[i].Value >>= nTemp16 )
2864 68 : pOptions->SetObjMode( VOBJ_TYPE_OLE, (nTemp16 == 1) ? VOBJ_MODE_HIDE : VOBJ_MODE_SHOW );
2865 : }
2866 2797 : else if ( sName == SC_UNO_SHOWCHARTS )
2867 : {
2868 : // #i80528# placeholders not supported anymore
2869 68 : if ( rSettings[i].Value >>= nTemp16 )
2870 68 : pOptions->SetObjMode( VOBJ_TYPE_CHART, (nTemp16 == 1) ? VOBJ_MODE_HIDE : VOBJ_MODE_SHOW );
2871 : }
2872 2729 : else if ( sName == SC_UNO_SHOWDRAW )
2873 : {
2874 : // #i80528# placeholders not supported anymore
2875 68 : if ( rSettings[i].Value >>= nTemp16 )
2876 68 : pOptions->SetObjMode( VOBJ_TYPE_DRAW, (nTemp16 == 1) ? VOBJ_MODE_HIDE : VOBJ_MODE_SHOW );
2877 : }
2878 2661 : else if ( sName.compareToAscii( SC_UNO_VALUEHIGH ) == 0 )
2879 225 : pOptions->SetOption( VOPT_SYNTAX, ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value ) );
2880 : else
2881 : {
2882 2436 : ScGridOptions aGridOpt(pOptions->GetGridOptions());
2883 2436 : if ( sName == SC_UNO_SNAPTORASTER )
2884 279 : aGridOpt.SetUseGridSnap( ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value ) );
2885 2157 : else if ( sName == SC_UNO_RASTERVIS )
2886 279 : aGridOpt.SetGridVisible( ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value ) );
2887 1878 : else if ( sName == SC_UNO_RASTERRESX )
2888 279 : aGridOpt.SetFieldDrawX( static_cast <sal_uInt32> ( ScUnoHelpFunctions::GetInt32FromAny( rSettings[i].Value ) ) );
2889 1599 : else if ( sName == SC_UNO_RASTERRESY )
2890 279 : aGridOpt.SetFieldDrawY( static_cast <sal_uInt32> ( ScUnoHelpFunctions::GetInt32FromAny( rSettings[i].Value ) ) );
2891 1320 : else if ( sName == SC_UNO_RASTERSUBX )
2892 279 : aGridOpt.SetFieldDivisionX( static_cast <sal_uInt32> ( ScUnoHelpFunctions::GetInt32FromAny( rSettings[i].Value ) ) );
2893 1041 : else if ( sName == SC_UNO_RASTERSUBY )
2894 279 : aGridOpt.SetFieldDivisionY( static_cast <sal_uInt32> ( ScUnoHelpFunctions::GetInt32FromAny( rSettings[i].Value ) ) );
2895 762 : else if ( sName == SC_UNO_RASTERSYNC )
2896 279 : aGridOpt.SetSynchronize( ScUnoHelpFunctions::GetBoolFromAny( rSettings[i].Value ) );
2897 2436 : pOptions->SetGridOptions(aGridOpt);
2898 : }
2899 7730 : }
2900 :
2901 : // copy default zoom to sheets where a different one wasn't specified
2902 1181 : for (SCTAB nZoomTab=0; nZoomTab< static_cast<SCTAB>(maTabData.size()); ++nZoomTab)
2903 834 : if (maTabData[nZoomTab] && ( nZoomTab >= static_cast<SCTAB>(aHasZoomVect.size()) || !aHasZoomVect[nZoomTab] ))
2904 : {
2905 0 : maTabData[nZoomTab]->eZoomType = eDefZoomType;
2906 0 : maTabData[nZoomTab]->aZoomX = aDefZoomX;
2907 0 : maTabData[nZoomTab]->aZoomY = aDefZoomY;
2908 0 : maTabData[nZoomTab]->aPageZoomX = aDefPageZoomX;
2909 0 : maTabData[nZoomTab]->aPageZoomY = aDefPageZoomY;
2910 : }
2911 :
2912 347 : if (nCount)
2913 347 : SetPagebreakMode( bPageMode );
2914 :
2915 : // #i47426# write view options to document, needed e.g. for Excel export
2916 347 : pDoc->SetViewOptions( *pOptions );
2917 347 : }
2918 :
2919 16 : void ScViewData::SetOptions( const ScViewOptions& rOpt )
2920 : {
2921 : // if visibility of horizontal ScrollBar is changed, TabBar may have to be resized...
2922 16 : bool bHScrollChanged = ( rOpt.GetOption(VOPT_HSCROLL) != pOptions->GetOption(VOPT_HSCROLL) );
2923 :
2924 : // if graphics are turned on or off, animation has to be started or stopped
2925 : // graphics are controlled by VOBJ_TYPE_OLE
2926 16 : bool bGraphicsChanged = ( pOptions->GetObjMode(VOBJ_TYPE_OLE) !=
2927 16 : rOpt.GetObjMode(VOBJ_TYPE_OLE) );
2928 :
2929 16 : *pOptions = rOpt;
2930 : OSL_ENSURE( pView, "No View" );
2931 :
2932 16 : if( pView )
2933 : {
2934 16 : pView->ViewOptionsHasChanged( bHScrollChanged, bGraphicsChanged );
2935 : }
2936 16 : }
2937 :
2938 0 : Point ScViewData::GetMousePosPixel()
2939 : {
2940 : OSL_ENSURE( pView, "GetMousePosPixel() ohne View" );
2941 0 : return pView->GetMousePosPixel();
2942 : }
2943 :
2944 0 : void ScViewData::UpdateInputHandler( bool bForce, bool bStopEditing )
2945 : {
2946 0 : if (pViewShell)
2947 0 : pViewShell->UpdateInputHandler( bForce, bStopEditing );
2948 0 : }
2949 :
2950 0 : bool ScViewData::IsOle()
2951 : {
2952 0 : return pDocShell && pDocShell->IsOle();
2953 : }
2954 :
2955 0 : bool ScViewData::UpdateFixX( SCTAB nTab ) // true = value changed
2956 : {
2957 0 : if (!ValidTab(nTab)) // Default
2958 0 : nTab=nTabNo; // current table
2959 :
2960 0 : if (!pView || maTabData[nTab]->eHSplitMode != SC_SPLIT_FIX)
2961 0 : return false;
2962 :
2963 0 : ScDocument* pLocalDoc = GetDocument();
2964 0 : if (!pLocalDoc->HasTable(nTab)) // if called from reload, the sheet may not exist
2965 0 : return false;
2966 :
2967 0 : SCCOL nFix = maTabData[nTab]->nFixPosX;
2968 0 : long nNewPos = 0;
2969 0 : for (SCCOL nX=maTabData[nTab]->nPosX[SC_SPLIT_LEFT]; nX<nFix; nX++)
2970 : {
2971 0 : sal_uInt16 nTSize = pLocalDoc->GetColWidth( nX, nTab );
2972 0 : if (nTSize)
2973 : {
2974 0 : long nPix = ToPixel( nTSize, nPPTX );
2975 0 : nNewPos += nPix;
2976 : }
2977 : }
2978 0 : nNewPos += pView->GetGridOffset().X();
2979 0 : if (nNewPos != maTabData[nTab]->nHSplitPos)
2980 : {
2981 0 : maTabData[nTab]->nHSplitPos = nNewPos;
2982 0 : if (nTab == nTabNo)
2983 0 : RecalcPixPos(); // should not be needed
2984 0 : return true;
2985 : }
2986 :
2987 0 : return false;
2988 : }
2989 :
2990 0 : bool ScViewData::UpdateFixY( SCTAB nTab ) // true = value changed
2991 : {
2992 0 : if (!ValidTab(nTab)) // Default
2993 0 : nTab=nTabNo; // current table
2994 :
2995 0 : if (!pView || maTabData[nTab]->eVSplitMode != SC_SPLIT_FIX)
2996 0 : return false;
2997 :
2998 0 : ScDocument* pLocalDoc = GetDocument();
2999 0 : if (!pLocalDoc->HasTable(nTab)) // if called from reload, the sheet may not exist
3000 0 : return false;
3001 :
3002 0 : SCROW nFix = maTabData[nTab]->nFixPosY;
3003 0 : long nNewPos = 0;
3004 0 : for (SCROW nY=maTabData[nTab]->nPosY[SC_SPLIT_TOP]; nY<nFix; nY++)
3005 : {
3006 0 : sal_uInt16 nTSize = pLocalDoc->GetRowHeight( nY, nTab );
3007 0 : if (nTSize)
3008 : {
3009 0 : long nPix = ToPixel( nTSize, nPPTY );
3010 0 : nNewPos += nPix;
3011 : }
3012 : }
3013 0 : nNewPos += pView->GetGridOffset().Y();
3014 0 : if (nNewPos != maTabData[nTab]->nVSplitPos)
3015 : {
3016 0 : maTabData[nTab]->nVSplitPos = nNewPos;
3017 0 : if (nTab == nTabNo)
3018 0 : RecalcPixPos(); // should not be needed
3019 0 : return true;
3020 : }
3021 :
3022 0 : return false;
3023 : }
3024 :
3025 0 : void ScViewData::UpdateOutlinerFlags( Outliner& rOutl ) const
3026 : {
3027 0 : ScDocument* pLocalDoc = GetDocument();
3028 0 : bool bOnlineSpell = pLocalDoc->GetDocOptions().IsAutoSpell();
3029 :
3030 0 : EEControlBits nCntrl = rOutl.GetControlWord();
3031 0 : nCntrl |= EEControlBits::MARKFIELDS;
3032 0 : nCntrl |= EEControlBits::AUTOCORRECT;
3033 0 : if( bOnlineSpell )
3034 0 : nCntrl |= EEControlBits::ONLINESPELLING;
3035 : else
3036 0 : nCntrl &= ~EEControlBits::ONLINESPELLING;
3037 0 : rOutl.SetControlWord(nCntrl);
3038 :
3039 0 : rOutl.SetCalcFieldValueHdl( LINK( SC_MOD(), ScModule, CalcFieldValueHdl ) );
3040 :
3041 : // don't call GetSpellChecker if online spelling isn't enabled.
3042 : // The language for AutoCorrect etc. is taken from the pool defaults
3043 : // (set in ScDocument::UpdateDrawLanguages)
3044 :
3045 0 : if ( bOnlineSpell )
3046 : {
3047 0 : com::sun::star::uno::Reference<com::sun::star::linguistic2::XSpellChecker1> xXSpellChecker1( LinguMgr::GetSpellChecker() );
3048 0 : rOutl.SetSpeller( xXSpellChecker1 );
3049 : }
3050 :
3051 : rOutl.SetDefaultHorizontalTextDirection(
3052 0 : (EEHorizontalTextDirection)pLocalDoc->GetEditTextDirection( nTabNo ) );
3053 0 : }
3054 :
3055 3038 : ScAddress ScViewData::GetCurPos() const
3056 : {
3057 3038 : return ScAddress( GetCurX(), GetCurY(), GetTabNo() );
3058 : }
3059 :
3060 86 : void ScViewData::SetRefStart( SCCOL nNewX, SCROW nNewY, SCTAB nNewZ )
3061 : {
3062 86 : nRefStartX = nNewX; nRefStartY = nNewY; nRefStartZ = nNewZ;
3063 86 : }
3064 :
3065 0 : void ScViewData::SetRefEnd( SCCOL nNewX, SCROW nNewY, SCTAB nNewZ )
3066 : {
3067 0 : nRefEndX = nNewX; nRefEndY = nNewY; nRefEndZ = nNewZ;
3068 0 : }
3069 :
3070 41919 : void ScViewData::AddPixelsWhile( long & rScrY, long nEndPixels, SCROW & rPosY,
3071 : SCROW nEndRow, double nPPTY, const ScDocument * pDoc, SCTAB nTabNo )
3072 : {
3073 41919 : SCROW nRow = rPosY;
3074 146415 : while (rScrY <= nEndPixels && nRow <= nEndRow)
3075 : {
3076 : SCROW nHeightEndRow;
3077 62577 : sal_uInt16 nHeight = pDoc->GetRowHeight( nRow, nTabNo, NULL, &nHeightEndRow);
3078 62577 : if (nHeightEndRow > nEndRow)
3079 0 : nHeightEndRow = nEndRow;
3080 62577 : if (!nHeight)
3081 635 : nRow = nHeightEndRow + 1;
3082 : else
3083 : {
3084 61942 : SCROW nRows = nHeightEndRow - nRow + 1;
3085 61942 : sal_Int64 nPixel = ToPixel( nHeight, nPPTY);
3086 61942 : sal_Int64 nAdd = nPixel * nRows;
3087 61942 : if (nAdd + rScrY > nEndPixels)
3088 : {
3089 41847 : sal_Int64 nDiff = rScrY + nAdd - nEndPixels;
3090 41847 : nRows -= static_cast<SCROW>(nDiff / nPixel);
3091 41847 : nAdd = nPixel * nRows;
3092 : // We're looking for a value that satisfies loop condition.
3093 41847 : if (nAdd + rScrY <= nEndPixels)
3094 : {
3095 3591 : ++nRows;
3096 3591 : nAdd += nPixel;
3097 : }
3098 : }
3099 61942 : rScrY += static_cast<long>(nAdd);
3100 61942 : nRow += nRows;
3101 : }
3102 : }
3103 41919 : if (nRow > rPosY)
3104 41919 : --nRow;
3105 41919 : rPosY = nRow;
3106 41919 : }
3107 :
3108 44 : void ScViewData::AddPixelsWhileBackward( long & rScrY, long nEndPixels,
3109 : SCROW & rPosY, SCROW nStartRow, double nPPTY, const ScDocument * pDoc,
3110 : SCTAB nTabNo )
3111 : {
3112 44 : SCROW nRow = rPosY;
3113 163 : while (rScrY <= nEndPixels && nRow >= nStartRow)
3114 : {
3115 : SCROW nHeightStartRow;
3116 75 : sal_uInt16 nHeight = pDoc->GetRowHeight( nRow, nTabNo, &nHeightStartRow, NULL);
3117 75 : if (nHeightStartRow < nStartRow)
3118 0 : nHeightStartRow = nStartRow;
3119 75 : if (!nHeight)
3120 0 : nRow = nHeightStartRow - 1;
3121 : else
3122 : {
3123 75 : SCROW nRows = nRow - nHeightStartRow + 1;
3124 75 : sal_Int64 nPixel = ToPixel( nHeight, nPPTY);
3125 75 : sal_Int64 nAdd = nPixel * nRows;
3126 75 : if (nAdd + rScrY > nEndPixels)
3127 : {
3128 23 : sal_Int64 nDiff = nAdd + rScrY - nEndPixels;
3129 23 : nRows -= static_cast<SCROW>(nDiff / nPixel);
3130 23 : nAdd = nPixel * nRows;
3131 : // We're looking for a value that satisfies loop condition.
3132 23 : if (nAdd + rScrY <= nEndPixels)
3133 : {
3134 0 : ++nRows;
3135 0 : nAdd += nPixel;
3136 : }
3137 : }
3138 75 : rScrY += static_cast<long>(nAdd);
3139 75 : nRow -= nRows;
3140 : }
3141 : }
3142 44 : if (nRow < rPosY)
3143 38 : ++nRow;
3144 44 : rPosY = nRow;
3145 200 : }
3146 :
3147 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
