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