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