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