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