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