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_sw.hxx"
26*b1cdbd2cSJim Jagielski /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil -*- */
27*b1cdbd2cSJim Jagielski
28*b1cdbd2cSJim Jagielski #include <com/sun/star/embed/ElementModes.hpp>
29*b1cdbd2cSJim Jagielski #include <com/sun/star/embed/XStorage.hpp>
30*b1cdbd2cSJim Jagielski
31*b1cdbd2cSJim Jagielski #include <hash_set>
32*b1cdbd2cSJim Jagielski #include <unotools/ucbstreamhelper.hxx>
33*b1cdbd2cSJim Jagielski #include <tools/solar.h>
34*b1cdbd2cSJim Jagielski #include <rtl/tencinfo.h>
35*b1cdbd2cSJim Jagielski #include <rtl/random.h>
36*b1cdbd2cSJim Jagielski
37*b1cdbd2cSJim Jagielski #include <sot/storage.hxx>
38*b1cdbd2cSJim Jagielski #include <sfx2/docinf.hxx>
39*b1cdbd2cSJim Jagielski #include <sfx2/docfile.hxx>
40*b1cdbd2cSJim Jagielski #include <sfx2/request.hxx>
41*b1cdbd2cSJim Jagielski #include <sfx2/frame.hxx>
42*b1cdbd2cSJim Jagielski #include <tools/urlobj.hxx>
43*b1cdbd2cSJim Jagielski #include <unotools/tempfile.hxx>
44*b1cdbd2cSJim Jagielski #include <svtools/sfxecode.hxx>
45*b1cdbd2cSJim Jagielski
46*b1cdbd2cSJim Jagielski #include <comphelper/docpasswordrequest.hxx>
47*b1cdbd2cSJim Jagielski #include <hintids.hxx>
48*b1cdbd2cSJim Jagielski
49*b1cdbd2cSJim Jagielski #include <editeng/tstpitem.hxx>
50*b1cdbd2cSJim Jagielski #include <editeng/cscoitem.hxx>
51*b1cdbd2cSJim Jagielski #include <svx/svdobj.hxx>
52*b1cdbd2cSJim Jagielski #include <svx/svdpage.hxx>
53*b1cdbd2cSJim Jagielski #include <editeng/paperinf.hxx>
54*b1cdbd2cSJim Jagielski #include <editeng/lrspitem.hxx> // SvxLRSpaceItem
55*b1cdbd2cSJim Jagielski #include <editeng/ulspitem.hxx>
56*b1cdbd2cSJim Jagielski #include <editeng/langitem.hxx>
57*b1cdbd2cSJim Jagielski #include <editeng/opaqitem.hxx>
58*b1cdbd2cSJim Jagielski #include <editeng/charhiddenitem.hxx>
59*b1cdbd2cSJim Jagielski #include <filter/msfilter/svxmsbas.hxx>
60*b1cdbd2cSJim Jagielski #include <svx/unoapi.hxx>
61*b1cdbd2cSJim Jagielski #include <svx/svdoole2.hxx>
62*b1cdbd2cSJim Jagielski #include <filter/msfilter/msdffimp.hxx>
63*b1cdbd2cSJim Jagielski #include <svx/svdoashp.hxx>
64*b1cdbd2cSJim Jagielski #include <svx/svxerr.hxx>
65*b1cdbd2cSJim Jagielski #include <filter/msfilter/mscodec.hxx>
66*b1cdbd2cSJim Jagielski #include <svx/svdmodel.hxx>
67*b1cdbd2cSJim Jagielski #include <svx/svdogrp.hxx>
68*b1cdbd2cSJim Jagielski #include <svx/xflclit.hxx>
69*b1cdbd2cSJim Jagielski
70*b1cdbd2cSJim Jagielski #include <unotools/fltrcfg.hxx>
71*b1cdbd2cSJim Jagielski #include <fmtfld.hxx>
72*b1cdbd2cSJim Jagielski #include <fmturl.hxx>
73*b1cdbd2cSJim Jagielski #include <fmtinfmt.hxx>
74*b1cdbd2cSJim Jagielski #include <IMark.hxx>
75*b1cdbd2cSJim Jagielski #include <reffld.hxx>
76*b1cdbd2cSJim Jagielski #include <fmthdft.hxx>
77*b1cdbd2cSJim Jagielski #include <fmtcntnt.hxx>
78*b1cdbd2cSJim Jagielski #include <fmtcnct.hxx>
79*b1cdbd2cSJim Jagielski #include <fmtanchr.hxx>
80*b1cdbd2cSJim Jagielski #include <fmtpdsc.hxx>
81*b1cdbd2cSJim Jagielski #include <ftninfo.hxx>
82*b1cdbd2cSJim Jagielski #include <fmtftn.hxx>
83*b1cdbd2cSJim Jagielski #include <txtftn.hxx>
84*b1cdbd2cSJim Jagielski #include <pam.hxx> // fuer SwPam
85*b1cdbd2cSJim Jagielski #include <doc.hxx>
86*b1cdbd2cSJim Jagielski #include <ndtxt.hxx> // class SwTxtNode
87*b1cdbd2cSJim Jagielski #include <pagedesc.hxx> // class SwPageDesc
88*b1cdbd2cSJim Jagielski #include <paratr.hxx>
89*b1cdbd2cSJim Jagielski #include <fmtclds.hxx>
90*b1cdbd2cSJim Jagielski #include <fmtclbl.hxx>
91*b1cdbd2cSJim Jagielski #include <section.hxx>
92*b1cdbd2cSJim Jagielski #include <docsh.hxx>
93*b1cdbd2cSJim Jagielski #include <docufld.hxx>
94*b1cdbd2cSJim Jagielski #include <swfltopt.hxx>
95*b1cdbd2cSJim Jagielski #include <viewsh.hxx>
96*b1cdbd2cSJim Jagielski #include <shellres.hxx>
97*b1cdbd2cSJim Jagielski #include <mdiexp.hxx> // Progress
98*b1cdbd2cSJim Jagielski #include <statstr.hrc> // ResId fuer Statusleiste
99*b1cdbd2cSJim Jagielski #include <swerror.h> // ERR_WW8_...
100*b1cdbd2cSJim Jagielski #include <swunodef.hxx>
101*b1cdbd2cSJim Jagielski #include <unodraw.hxx>
102*b1cdbd2cSJim Jagielski #include <swtable.hxx> // class SwTableLines, ...
103*b1cdbd2cSJim Jagielski // #i18732#
104*b1cdbd2cSJim Jagielski #include <fmtfollowtextflow.hxx>
105*b1cdbd2cSJim Jagielski #include <fchrfmt.hxx>
106*b1cdbd2cSJim Jagielski #include <charfmt.hxx>
107*b1cdbd2cSJim Jagielski
108*b1cdbd2cSJim Jagielski
109*b1cdbd2cSJim Jagielski #include <com/sun/star/i18n/ForbiddenCharacters.hpp>
110*b1cdbd2cSJim Jagielski #include <comphelper/extract.hxx>
111*b1cdbd2cSJim Jagielski #include <comphelper/sequenceashashmap.hxx>
112*b1cdbd2cSJim Jagielski #include <fltini.hxx>
113*b1cdbd2cSJim Jagielski
114*b1cdbd2cSJim Jagielski #include <algorithm>
115*b1cdbd2cSJim Jagielski #include <functional>
116*b1cdbd2cSJim Jagielski #include "writerhelper.hxx"
117*b1cdbd2cSJim Jagielski #include "writerwordglue.hxx"
118*b1cdbd2cSJim Jagielski
119*b1cdbd2cSJim Jagielski #include "ndgrf.hxx"
120*b1cdbd2cSJim Jagielski #include <editeng/brshitem.hxx>
121*b1cdbd2cSJim Jagielski #include <editeng/editids.hrc>
122*b1cdbd2cSJim Jagielski #include <txtflcnt.hxx>
123*b1cdbd2cSJim Jagielski #include <fmtflcnt.hxx>
124*b1cdbd2cSJim Jagielski #include <txatbase.hxx>
125*b1cdbd2cSJim Jagielski
126*b1cdbd2cSJim Jagielski #include "ww8par2.hxx" // class WW8RStyle, class WW8AnchorPara
127*b1cdbd2cSJim Jagielski
128*b1cdbd2cSJim Jagielski #include <frmatr.hxx>
129*b1cdbd2cSJim Jagielski
130*b1cdbd2cSJim Jagielski #include <math.h>
131*b1cdbd2cSJim Jagielski #include <com/sun/star/beans/XPropertyContainer.hpp>
132*b1cdbd2cSJim Jagielski
133*b1cdbd2cSJim Jagielski #include <com/sun/star/beans/PropertyAttribute.hpp>
134*b1cdbd2cSJim Jagielski #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
135*b1cdbd2cSJim Jagielski #include <com/sun/star/document/XDocumentProperties.hpp>
136*b1cdbd2cSJim Jagielski #include <svl/itemiter.hxx> //SfxItemIter
137*b1cdbd2cSJim Jagielski
138*b1cdbd2cSJim Jagielski #include <stdio.h>
139*b1cdbd2cSJim Jagielski
140*b1cdbd2cSJim Jagielski #ifdef DEBUG
141*b1cdbd2cSJim Jagielski #include <iostream>
142*b1cdbd2cSJim Jagielski #include <dbgoutsw.hxx>
143*b1cdbd2cSJim Jagielski #endif
144*b1cdbd2cSJim Jagielski #include <svx/hlnkitem.hxx>
145*b1cdbd2cSJim Jagielski #include "WW8Sttbf.hxx"
146*b1cdbd2cSJim Jagielski #include "WW8FibData.hxx"
147*b1cdbd2cSJim Jagielski #define MM_250 1417 // WW-Default fuer Hor. Seitenraender: 2.5 cm
148*b1cdbd2cSJim Jagielski #define MM_200 1134 // WW-Default fuer u.Seitenrand: 2.0 cm
149*b1cdbd2cSJim Jagielski
150*b1cdbd2cSJim Jagielski using namespace ::com::sun::star;
151*b1cdbd2cSJim Jagielski using namespace sw::util;
152*b1cdbd2cSJim Jagielski using namespace sw::types;
153*b1cdbd2cSJim Jagielski using namespace nsHdFtFlags;
154*b1cdbd2cSJim Jagielski
155*b1cdbd2cSJim Jagielski #define VT_EMPTY 0
156*b1cdbd2cSJim Jagielski #define VT_I4 3
157*b1cdbd2cSJim Jagielski #define VT_LPSTR 30
158*b1cdbd2cSJim Jagielski #define VT_LPWSTR 31
159*b1cdbd2cSJim Jagielski #define VT_BLOB 65
160*b1cdbd2cSJim Jagielski #define VT_TYPEMASK 0xFFF
161*b1cdbd2cSJim Jagielski /** Expands to a pointer behind the last element of a STATIC data array (like STL end()). */
162*b1cdbd2cSJim Jagielski #define STATIC_TABLE_END( array ) ((array)+STATIC_TABLE_SIZE(array))
163*b1cdbd2cSJim Jagielski /** Expands to the size of a STATIC data array. */
164*b1cdbd2cSJim Jagielski #define STATIC_TABLE_SIZE( array ) (sizeof(array)/sizeof(*(array)))
165*b1cdbd2cSJim Jagielski
GetMacroInfo(SdrObject * pObj,sal_Bool bCreate)166*b1cdbd2cSJim Jagielski SwMacroInfo* GetMacroInfo( SdrObject* pObj, sal_Bool bCreate ) // static
167*b1cdbd2cSJim Jagielski {
168*b1cdbd2cSJim Jagielski if ( pObj )
169*b1cdbd2cSJim Jagielski {
170*b1cdbd2cSJim Jagielski sal_uInt16 nCount = pObj->GetUserDataCount();
171*b1cdbd2cSJim Jagielski for( sal_uInt16 i = 0; i < nCount; i++ )
172*b1cdbd2cSJim Jagielski {
173*b1cdbd2cSJim Jagielski SdrObjUserData* pData = pObj->GetUserData( i );
174*b1cdbd2cSJim Jagielski if( pData && pData->GetInventor() == SW_DRAWLAYER
175*b1cdbd2cSJim Jagielski && pData->GetId() == SW_UD_IMAPDATA)
176*b1cdbd2cSJim Jagielski return dynamic_cast<SwMacroInfo*>(pData);
177*b1cdbd2cSJim Jagielski }
178*b1cdbd2cSJim Jagielski if ( bCreate )
179*b1cdbd2cSJim Jagielski {
180*b1cdbd2cSJim Jagielski SwMacroInfo* pData = new SwMacroInfo;
181*b1cdbd2cSJim Jagielski pObj->InsertUserData( pData, 0 );
182*b1cdbd2cSJim Jagielski return pData;
183*b1cdbd2cSJim Jagielski }
184*b1cdbd2cSJim Jagielski }
185*b1cdbd2cSJim Jagielski
186*b1cdbd2cSJim Jagielski return 0;
187*b1cdbd2cSJim Jagielski };
188*b1cdbd2cSJim Jagielski
lclGetAbsPath(String & rPath,sal_uInt16 nLevel,SwDocShell * pDocShell)189*b1cdbd2cSJim Jagielski void lclGetAbsPath( String& rPath, sal_uInt16 nLevel, SwDocShell* pDocShell)
190*b1cdbd2cSJim Jagielski {
191*b1cdbd2cSJim Jagielski String aTmpStr;
192*b1cdbd2cSJim Jagielski while( nLevel )
193*b1cdbd2cSJim Jagielski {
194*b1cdbd2cSJim Jagielski aTmpStr.AppendAscii( "../" );
195*b1cdbd2cSJim Jagielski --nLevel;
196*b1cdbd2cSJim Jagielski }
197*b1cdbd2cSJim Jagielski if(aTmpStr.Len())
198*b1cdbd2cSJim Jagielski aTmpStr += rPath;
199*b1cdbd2cSJim Jagielski else
200*b1cdbd2cSJim Jagielski aTmpStr = rPath;
201*b1cdbd2cSJim Jagielski
202*b1cdbd2cSJim Jagielski if(aTmpStr.Len())
203*b1cdbd2cSJim Jagielski {
204*b1cdbd2cSJim Jagielski bool bWasAbs = false;
205*b1cdbd2cSJim Jagielski rPath = pDocShell->GetMedium()->GetURLObject().smartRel2Abs( aTmpStr, bWasAbs ).GetMainURL( INetURLObject::NO_DECODE );
206*b1cdbd2cSJim Jagielski // full path as stored in SvxURLField must be encoded
207*b1cdbd2cSJim Jagielski }
208*b1cdbd2cSJim Jagielski }
209*b1cdbd2cSJim Jagielski
lclIgnoreString32(SvMemoryStream & rStrm,bool b16Bit)210*b1cdbd2cSJim Jagielski void lclIgnoreString32( SvMemoryStream& rStrm, bool b16Bit )
211*b1cdbd2cSJim Jagielski {
212*b1cdbd2cSJim Jagielski sal_uInt32 nChars;
213*b1cdbd2cSJim Jagielski rStrm >> nChars;
214*b1cdbd2cSJim Jagielski if( b16Bit )
215*b1cdbd2cSJim Jagielski nChars *= 2;
216*b1cdbd2cSJim Jagielski rStrm.SeekRel( nChars );
217*b1cdbd2cSJim Jagielski }
218*b1cdbd2cSJim Jagielski
ReadRawUniString(SvMemoryStream & rStrm,sal_uInt16 nChars,bool b16Bit)219*b1cdbd2cSJim Jagielski String SwWW8ImplReader::ReadRawUniString( SvMemoryStream& rStrm,sal_uInt16 nChars, bool b16Bit )
220*b1cdbd2cSJim Jagielski {
221*b1cdbd2cSJim Jagielski // Fixed-size characters
222*b1cdbd2cSJim Jagielski const sal_uInt8 WW8_NUL_C = '\x00'; /// NUL chararcter.
223*b1cdbd2cSJim Jagielski const sal_uInt16 WW8_NUL = WW8_NUL_C; /// NUL chararcter (unicode).
224*b1cdbd2cSJim Jagielski String aRet;
225*b1cdbd2cSJim Jagielski sal_Unicode mcNulSubst = '\0';
226*b1cdbd2cSJim Jagielski
227*b1cdbd2cSJim Jagielski sal_uInt16 nCharsLeft = nChars;
228*b1cdbd2cSJim Jagielski sal_Unicode* pcBuffer = new sal_Unicode[ nCharsLeft + 1 ];
229*b1cdbd2cSJim Jagielski
230*b1cdbd2cSJim Jagielski sal_Unicode* pcUniChar = pcBuffer;
231*b1cdbd2cSJim Jagielski sal_Unicode* pcEndChar = pcBuffer + nCharsLeft;
232*b1cdbd2cSJim Jagielski
233*b1cdbd2cSJim Jagielski if( b16Bit )
234*b1cdbd2cSJim Jagielski {
235*b1cdbd2cSJim Jagielski sal_uInt16 nReadChar;
236*b1cdbd2cSJim Jagielski for( ; (pcUniChar < pcEndChar); ++pcUniChar )
237*b1cdbd2cSJim Jagielski {
238*b1cdbd2cSJim Jagielski rStrm >> (nReadChar);
239*b1cdbd2cSJim Jagielski (*pcUniChar) = (nReadChar == WW8_NUL) ? mcNulSubst : static_cast< sal_Unicode >( nReadChar );
240*b1cdbd2cSJim Jagielski }
241*b1cdbd2cSJim Jagielski }
242*b1cdbd2cSJim Jagielski else
243*b1cdbd2cSJim Jagielski {
244*b1cdbd2cSJim Jagielski sal_uInt8 nReadChar;
245*b1cdbd2cSJim Jagielski for( ; (pcUniChar < pcEndChar); ++pcUniChar )
246*b1cdbd2cSJim Jagielski {
247*b1cdbd2cSJim Jagielski rStrm >> nReadChar ;
248*b1cdbd2cSJim Jagielski (*pcUniChar) = (nReadChar == WW8_NUL_C) ? mcNulSubst : static_cast< sal_Unicode >( nReadChar );
249*b1cdbd2cSJim Jagielski }
250*b1cdbd2cSJim Jagielski }
251*b1cdbd2cSJim Jagielski
252*b1cdbd2cSJim Jagielski *pcEndChar = '\0';
253*b1cdbd2cSJim Jagielski aRet.Append( pcBuffer );
254*b1cdbd2cSJim Jagielski delete[] pcBuffer;
255*b1cdbd2cSJim Jagielski return aRet;
256*b1cdbd2cSJim Jagielski }
257*b1cdbd2cSJim Jagielski
lclAppendString32(String & rString,SvMemoryStream & rStrm,sal_uInt32 nChars,bool b16Bit)258*b1cdbd2cSJim Jagielski void lclAppendString32( String& rString, SvMemoryStream& rStrm, sal_uInt32 nChars, bool b16Bit )
259*b1cdbd2cSJim Jagielski {
260*b1cdbd2cSJim Jagielski sal_uInt16 nReadChars = ulimit_cast< sal_uInt16 >( nChars );
261*b1cdbd2cSJim Jagielski String urlStr = SwWW8ImplReader::ReadRawUniString( rStrm, nReadChars, b16Bit );
262*b1cdbd2cSJim Jagielski rString.Append( urlStr );
263*b1cdbd2cSJim Jagielski }
264*b1cdbd2cSJim Jagielski
lclAppendString32(String & rString,SvMemoryStream & rStrm,bool b16Bit)265*b1cdbd2cSJim Jagielski void lclAppendString32( String& rString, SvMemoryStream& rStrm, bool b16Bit )
266*b1cdbd2cSJim Jagielski {
267*b1cdbd2cSJim Jagielski sal_uInt32 nValue;
268*b1cdbd2cSJim Jagielski rStrm >>( nValue );
269*b1cdbd2cSJim Jagielski lclAppendString32( rString, rStrm, nValue, b16Bit );
270*b1cdbd2cSJim Jagielski }
271*b1cdbd2cSJim Jagielski
ReadEmbeddedData(SvMemoryStream & rStrm,SwDocShell * pDocShell,struct HyperLinksTable & hlStr)272*b1cdbd2cSJim Jagielski void SwWW8ImplReader::ReadEmbeddedData( SvMemoryStream& rStrm, SwDocShell* pDocShell, struct HyperLinksTable& hlStr)
273*b1cdbd2cSJim Jagielski {
274*b1cdbd2cSJim Jagielski // (0x01B8) HLINK -------------------------------------------------------------
275*b1cdbd2cSJim Jagielski // const sal_uInt16 WW8_ID_HLINK = 0x01B8;
276*b1cdbd2cSJim Jagielski const sal_uInt32 WW8_HLINK_BODY = 0x00000001; /// Contains file link or URL.
277*b1cdbd2cSJim Jagielski const sal_uInt32 WW8_HLINK_ABS = 0x00000002; /// Absolute path.
278*b1cdbd2cSJim Jagielski const sal_uInt32 WW8_HLINK_DESCR = 0x00000014; /// Description.
279*b1cdbd2cSJim Jagielski const sal_uInt32 WW8_HLINK_MARK = 0x00000008; /// Text mark.
280*b1cdbd2cSJim Jagielski const sal_uInt32 WW8_HLINK_FRAME = 0x00000080; /// Target frame.
281*b1cdbd2cSJim Jagielski const sal_uInt32 WW8_HLINK_UNC = 0x00000100; /// UNC path.
282*b1cdbd2cSJim Jagielski
283*b1cdbd2cSJim Jagielski // sal_uInt8 maGuidStdLink[ 16 ] ={
284*b1cdbd2cSJim Jagielski // 0xD0, 0xC9, 0xEA, 0x79, 0xF9, 0xBA, 0xCE, 0x11, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B };
285*b1cdbd2cSJim Jagielski
286*b1cdbd2cSJim Jagielski sal_uInt8 maGuidUrlMoniker[ 16 ] = {
287*b1cdbd2cSJim Jagielski 0xE0, 0xC9, 0xEA, 0x79, 0xF9, 0xBA, 0xCE, 0x11, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B };
288*b1cdbd2cSJim Jagielski
289*b1cdbd2cSJim Jagielski sal_uInt8 maGuidFileMoniker[ 16 ] = {
290*b1cdbd2cSJim Jagielski 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 };
291*b1cdbd2cSJim Jagielski
292*b1cdbd2cSJim Jagielski sal_uInt8* aGuid = new sal_uInt8[ 16 ];
293*b1cdbd2cSJim Jagielski sal_uInt32 nFlags;
294*b1cdbd2cSJim Jagielski
295*b1cdbd2cSJim Jagielski
296*b1cdbd2cSJim Jagielski rStrm.Read( aGuid, 16);
297*b1cdbd2cSJim Jagielski rStrm.SeekRel( 4 );
298*b1cdbd2cSJim Jagielski rStrm >> nFlags;
299*b1cdbd2cSJim Jagielski
300*b1cdbd2cSJim Jagielski sal_uInt16 nLevel = 0; // counter for level to climb down in path
301*b1cdbd2cSJim Jagielski ::std::auto_ptr< String > xLongName; // link / file name
302*b1cdbd2cSJim Jagielski ::std::auto_ptr< String > xShortName; // 8.3-representation of file name
303*b1cdbd2cSJim Jagielski ::std::auto_ptr< String > xTextMark; // text mark
304*b1cdbd2cSJim Jagielski
305*b1cdbd2cSJim Jagielski // description (ignore)
306*b1cdbd2cSJim Jagielski if( ::get_flag( nFlags, WW8_HLINK_DESCR ) )
307*b1cdbd2cSJim Jagielski lclIgnoreString32( rStrm, true );
308*b1cdbd2cSJim Jagielski
309*b1cdbd2cSJim Jagielski // target frame
310*b1cdbd2cSJim Jagielski if( ::get_flag( nFlags, WW8_HLINK_FRAME ) )
311*b1cdbd2cSJim Jagielski {
312*b1cdbd2cSJim Jagielski ::std::auto_ptr< String > FrmName;
313*b1cdbd2cSJim Jagielski FrmName.reset( new String );
314*b1cdbd2cSJim Jagielski lclAppendString32(*FrmName , rStrm , true);
315*b1cdbd2cSJim Jagielski hlStr.tarFrm = *FrmName;
316*b1cdbd2cSJim Jagielski }
317*b1cdbd2cSJim Jagielski
318*b1cdbd2cSJim Jagielski // UNC path
319*b1cdbd2cSJim Jagielski if( ::get_flag( nFlags, WW8_HLINK_UNC ) )
320*b1cdbd2cSJim Jagielski {
321*b1cdbd2cSJim Jagielski xLongName.reset( new String );
322*b1cdbd2cSJim Jagielski lclAppendString32( *xLongName, rStrm, true );
323*b1cdbd2cSJim Jagielski lclGetAbsPath( *xLongName, 0 , pDocShell);
324*b1cdbd2cSJim Jagielski }
325*b1cdbd2cSJim Jagielski // file link or URL
326*b1cdbd2cSJim Jagielski else if( ::get_flag( nFlags, WW8_HLINK_BODY ) )
327*b1cdbd2cSJim Jagielski {
328*b1cdbd2cSJim Jagielski rStrm.Read( aGuid, 16);
329*b1cdbd2cSJim Jagielski
330*b1cdbd2cSJim Jagielski if( (memcmp(aGuid, maGuidFileMoniker, 16) == 0) )
331*b1cdbd2cSJim Jagielski {
332*b1cdbd2cSJim Jagielski rStrm >> nLevel;
333*b1cdbd2cSJim Jagielski xShortName.reset( new String );
334*b1cdbd2cSJim Jagielski lclAppendString32( *xShortName,rStrm, false );
335*b1cdbd2cSJim Jagielski rStrm.SeekRel( 24 );
336*b1cdbd2cSJim Jagielski
337*b1cdbd2cSJim Jagielski sal_uInt32 nStrLen;
338*b1cdbd2cSJim Jagielski rStrm >> nStrLen;
339*b1cdbd2cSJim Jagielski if( nStrLen )
340*b1cdbd2cSJim Jagielski {
341*b1cdbd2cSJim Jagielski rStrm >> nStrLen;
342*b1cdbd2cSJim Jagielski nStrLen /= 2;
343*b1cdbd2cSJim Jagielski rStrm.SeekRel( 2 );
344*b1cdbd2cSJim Jagielski xLongName.reset( new String );
345*b1cdbd2cSJim Jagielski lclAppendString32( *xLongName, rStrm,nStrLen, true );
346*b1cdbd2cSJim Jagielski lclGetAbsPath( *xLongName, nLevel, pDocShell);
347*b1cdbd2cSJim Jagielski }
348*b1cdbd2cSJim Jagielski else
349*b1cdbd2cSJim Jagielski lclGetAbsPath( *xShortName, nLevel, pDocShell);
350*b1cdbd2cSJim Jagielski }
351*b1cdbd2cSJim Jagielski else if( (memcmp(aGuid, maGuidUrlMoniker, 16) == 0) )
352*b1cdbd2cSJim Jagielski {
353*b1cdbd2cSJim Jagielski sal_uInt32 nStrLen;
354*b1cdbd2cSJim Jagielski rStrm >> nStrLen;
355*b1cdbd2cSJim Jagielski nStrLen /= 2;
356*b1cdbd2cSJim Jagielski xLongName.reset( new String );
357*b1cdbd2cSJim Jagielski lclAppendString32( *xLongName,rStrm, nStrLen, true );
358*b1cdbd2cSJim Jagielski if( !::get_flag( nFlags, WW8_HLINK_ABS ) )
359*b1cdbd2cSJim Jagielski lclGetAbsPath( *xLongName, 0 ,pDocShell);
360*b1cdbd2cSJim Jagielski }
361*b1cdbd2cSJim Jagielski else
362*b1cdbd2cSJim Jagielski {
363*b1cdbd2cSJim Jagielski DBG_ERRORFILE( "WW8Hyperlink::ReadEmbeddedData - unknown content GUID" );
364*b1cdbd2cSJim Jagielski }
365*b1cdbd2cSJim Jagielski }
366*b1cdbd2cSJim Jagielski
367*b1cdbd2cSJim Jagielski // text mark
368*b1cdbd2cSJim Jagielski if( ::get_flag( nFlags, WW8_HLINK_MARK ) )
369*b1cdbd2cSJim Jagielski {
370*b1cdbd2cSJim Jagielski xTextMark.reset( new String );
371*b1cdbd2cSJim Jagielski lclAppendString32( *xTextMark, rStrm, true );
372*b1cdbd2cSJim Jagielski }
373*b1cdbd2cSJim Jagielski
374*b1cdbd2cSJim Jagielski if( !xLongName.get() && xShortName.get() )
375*b1cdbd2cSJim Jagielski {
376*b1cdbd2cSJim Jagielski xLongName.reset( new String );
377*b1cdbd2cSJim Jagielski xLongName->Append(*xShortName);
378*b1cdbd2cSJim Jagielski }
379*b1cdbd2cSJim Jagielski else if( !xLongName.get() && xTextMark.get() )
380*b1cdbd2cSJim Jagielski xLongName.reset( new String );
381*b1cdbd2cSJim Jagielski
382*b1cdbd2cSJim Jagielski if( xLongName.get() )
383*b1cdbd2cSJim Jagielski {
384*b1cdbd2cSJim Jagielski if( xTextMark.get() )
385*b1cdbd2cSJim Jagielski {
386*b1cdbd2cSJim Jagielski if( xLongName->Len() == 0 )
387*b1cdbd2cSJim Jagielski xTextMark->SearchAndReplaceAll( '!', '.' );
388*b1cdbd2cSJim Jagielski xLongName->Append( '#' );
389*b1cdbd2cSJim Jagielski xLongName->Append( *xTextMark );
390*b1cdbd2cSJim Jagielski }
391*b1cdbd2cSJim Jagielski hlStr.hLinkAddr = *xLongName;
392*b1cdbd2cSJim Jagielski }
393*b1cdbd2cSJim Jagielski }
394*b1cdbd2cSJim Jagielski
SwMSDffManager(SwWW8ImplReader & rRdr)395*b1cdbd2cSJim Jagielski SwMSDffManager::SwMSDffManager( SwWW8ImplReader& rRdr )
396*b1cdbd2cSJim Jagielski : SvxMSDffManager(*rRdr.pTableStream, rRdr.GetBaseURL(), rRdr.pWwFib->fcDggInfo,
397*b1cdbd2cSJim Jagielski rRdr.pDataStream, 0, 0, COL_WHITE, 12, rRdr.pStrm,
398*b1cdbd2cSJim Jagielski rRdr.maTracer.GetTrace()),
399*b1cdbd2cSJim Jagielski rReader(rRdr), pFallbackStream(0), pOldEscherBlipCache(0)
400*b1cdbd2cSJim Jagielski {
401*b1cdbd2cSJim Jagielski SetSvxMSDffSettings( GetSvxMSDffSettings() );
402*b1cdbd2cSJim Jagielski nSvxMSDffOLEConvFlags = SwMSDffManager::GetFilterFlags();
403*b1cdbd2cSJim Jagielski }
404*b1cdbd2cSJim Jagielski
GetFilterFlags()405*b1cdbd2cSJim Jagielski sal_uInt32 SwMSDffManager::GetFilterFlags()
406*b1cdbd2cSJim Jagielski {
407*b1cdbd2cSJim Jagielski sal_uInt32 nFlags(0);
408*b1cdbd2cSJim Jagielski if (const SvtFilterOptions* pOpt = SvtFilterOptions::Get())
409*b1cdbd2cSJim Jagielski {
410*b1cdbd2cSJim Jagielski if (pOpt->IsMathType2Math())
411*b1cdbd2cSJim Jagielski nFlags |= OLE_MATHTYPE_2_STARMATH;
412*b1cdbd2cSJim Jagielski if (pOpt->IsExcel2Calc())
413*b1cdbd2cSJim Jagielski nFlags |= OLE_EXCEL_2_STARCALC;
414*b1cdbd2cSJim Jagielski if (pOpt->IsPowerPoint2Impress())
415*b1cdbd2cSJim Jagielski nFlags |= OLE_POWERPOINT_2_STARIMPRESS;
416*b1cdbd2cSJim Jagielski if (pOpt->IsWinWord2Writer())
417*b1cdbd2cSJim Jagielski nFlags |= OLE_WINWORD_2_STARWRITER;
418*b1cdbd2cSJim Jagielski }
419*b1cdbd2cSJim Jagielski return nFlags;
420*b1cdbd2cSJim Jagielski }
421*b1cdbd2cSJim Jagielski
422*b1cdbd2cSJim Jagielski /*
423*b1cdbd2cSJim Jagielski * I would like to override the default OLE importing to add a test
424*b1cdbd2cSJim Jagielski * and conversion of OCX controls from their native OLE type into our
425*b1cdbd2cSJim Jagielski * native nonOLE Form Control Objects.
426*b1cdbd2cSJim Jagielski *
427*b1cdbd2cSJim Jagielski * cmc
428*b1cdbd2cSJim Jagielski */
429*b1cdbd2cSJim Jagielski // #i32596# - consider new parameter <_nCalledByGroup>
ImportOLE(long nOLEId,const Graphic & rGrf,const Rectangle & rBoundRect,const Rectangle & rVisArea,const int _nCalledByGroup,sal_Int64 nAspect) const430*b1cdbd2cSJim Jagielski SdrObject* SwMSDffManager::ImportOLE( long nOLEId,
431*b1cdbd2cSJim Jagielski const Graphic& rGrf,
432*b1cdbd2cSJim Jagielski const Rectangle& rBoundRect,
433*b1cdbd2cSJim Jagielski const Rectangle& rVisArea,
434*b1cdbd2cSJim Jagielski const int _nCalledByGroup,
435*b1cdbd2cSJim Jagielski sal_Int64 nAspect ) const
436*b1cdbd2cSJim Jagielski {
437*b1cdbd2cSJim Jagielski // #i32596# - no import of OLE object, if it's inside a group.
438*b1cdbd2cSJim Jagielski // NOTE: This can be undone, if grouping of Writer fly frames is possible or
439*b1cdbd2cSJim Jagielski // if drawing OLE objects are allowed in Writer.
440*b1cdbd2cSJim Jagielski if ( _nCalledByGroup > 0 )
441*b1cdbd2cSJim Jagielski {
442*b1cdbd2cSJim Jagielski return 0L;
443*b1cdbd2cSJim Jagielski }
444*b1cdbd2cSJim Jagielski
445*b1cdbd2cSJim Jagielski SdrObject* pRet = 0;
446*b1cdbd2cSJim Jagielski String sStorageName;
447*b1cdbd2cSJim Jagielski SotStorageRef xSrcStg;
448*b1cdbd2cSJim Jagielski uno::Reference < embed::XStorage > xDstStg;
449*b1cdbd2cSJim Jagielski if( GetOLEStorageName( nOLEId, sStorageName, xSrcStg, xDstStg ))
450*b1cdbd2cSJim Jagielski {
451*b1cdbd2cSJim Jagielski SvStorageRef xSrc = xSrcStg->OpenSotStorage( sStorageName,
452*b1cdbd2cSJim Jagielski STREAM_READWRITE| STREAM_SHARE_DENYALL );
453*b1cdbd2cSJim Jagielski ASSERT(rReader.pFormImpl, "No Form Implementation!");
454*b1cdbd2cSJim Jagielski STAR_REFERENCE( drawing::XShape ) xShape;
455*b1cdbd2cSJim Jagielski if ( (!(rReader.bIsHeader || rReader.bIsFooter)) &&
456*b1cdbd2cSJim Jagielski rReader.pFormImpl->ReadOCXStream(xSrc,&xShape,true))
457*b1cdbd2cSJim Jagielski {
458*b1cdbd2cSJim Jagielski pRet = GetSdrObjectFromXShape(xShape);
459*b1cdbd2cSJim Jagielski }
460*b1cdbd2cSJim Jagielski else
461*b1cdbd2cSJim Jagielski {
462*b1cdbd2cSJim Jagielski ErrCode nError = ERRCODE_NONE;
463*b1cdbd2cSJim Jagielski pRet = CreateSdrOLEFromStorage( sStorageName, xSrcStg, xDstStg,
464*b1cdbd2cSJim Jagielski rGrf, rBoundRect, rVisArea, pStData, nError, nSvxMSDffOLEConvFlags, nAspect );
465*b1cdbd2cSJim Jagielski }
466*b1cdbd2cSJim Jagielski }
467*b1cdbd2cSJim Jagielski return pRet;
468*b1cdbd2cSJim Jagielski }
469*b1cdbd2cSJim Jagielski
DisableFallbackStream()470*b1cdbd2cSJim Jagielski void SwMSDffManager::DisableFallbackStream()
471*b1cdbd2cSJim Jagielski {
472*b1cdbd2cSJim Jagielski ASSERT(!pFallbackStream || !pOldEscherBlipCache,
473*b1cdbd2cSJim Jagielski "if you're recursive, you're broken");
474*b1cdbd2cSJim Jagielski pFallbackStream = pStData2;
475*b1cdbd2cSJim Jagielski pOldEscherBlipCache = pEscherBlipCache;
476*b1cdbd2cSJim Jagielski pEscherBlipCache = 0;
477*b1cdbd2cSJim Jagielski pStData2 = 0;
478*b1cdbd2cSJim Jagielski }
479*b1cdbd2cSJim Jagielski
EnableFallbackStream()480*b1cdbd2cSJim Jagielski void SwMSDffManager::EnableFallbackStream()
481*b1cdbd2cSJim Jagielski {
482*b1cdbd2cSJim Jagielski pStData2 = pFallbackStream;
483*b1cdbd2cSJim Jagielski pEscherBlipCache = pOldEscherBlipCache;
484*b1cdbd2cSJim Jagielski pOldEscherBlipCache = 0;
485*b1cdbd2cSJim Jagielski pFallbackStream = 0;
486*b1cdbd2cSJim Jagielski }
487*b1cdbd2cSJim Jagielski
GetToggleAttrFlags() const488*b1cdbd2cSJim Jagielski sal_uInt16 SwWW8ImplReader::GetToggleAttrFlags() const
489*b1cdbd2cSJim Jagielski {
490*b1cdbd2cSJim Jagielski return pCtrlStck ? pCtrlStck->GetToggleAttrFlags() : 0;
491*b1cdbd2cSJim Jagielski }
492*b1cdbd2cSJim Jagielski
GetToggleBiDiAttrFlags() const493*b1cdbd2cSJim Jagielski sal_uInt16 SwWW8ImplReader::GetToggleBiDiAttrFlags() const
494*b1cdbd2cSJim Jagielski {
495*b1cdbd2cSJim Jagielski return pCtrlStck ? pCtrlStck->GetToggleBiDiAttrFlags() : 0;
496*b1cdbd2cSJim Jagielski }
497*b1cdbd2cSJim Jagielski
SetToggleAttrFlags(sal_uInt16 nFlags)498*b1cdbd2cSJim Jagielski void SwWW8ImplReader::SetToggleAttrFlags(sal_uInt16 nFlags)
499*b1cdbd2cSJim Jagielski {
500*b1cdbd2cSJim Jagielski if (pCtrlStck)
501*b1cdbd2cSJim Jagielski pCtrlStck->SetToggleAttrFlags(nFlags);
502*b1cdbd2cSJim Jagielski }
503*b1cdbd2cSJim Jagielski
SetToggleBiDiAttrFlags(sal_uInt16 nFlags)504*b1cdbd2cSJim Jagielski void SwWW8ImplReader::SetToggleBiDiAttrFlags(sal_uInt16 nFlags)
505*b1cdbd2cSJim Jagielski {
506*b1cdbd2cSJim Jagielski if (pCtrlStck)
507*b1cdbd2cSJim Jagielski pCtrlStck->SetToggleBiDiAttrFlags(nFlags);
508*b1cdbd2cSJim Jagielski }
509*b1cdbd2cSJim Jagielski
510*b1cdbd2cSJim Jagielski
ProcessObj(SvStream & rSt,DffObjData & rObjData,void * pData,Rectangle & rTextRect,SdrObject * pObj)511*b1cdbd2cSJim Jagielski SdrObject* SwMSDffManager::ProcessObj(SvStream& rSt,
512*b1cdbd2cSJim Jagielski DffObjData& rObjData,
513*b1cdbd2cSJim Jagielski void* pData,
514*b1cdbd2cSJim Jagielski Rectangle& rTextRect,
515*b1cdbd2cSJim Jagielski SdrObject* pObj
516*b1cdbd2cSJim Jagielski )
517*b1cdbd2cSJim Jagielski {
518*b1cdbd2cSJim Jagielski if( !rTextRect.IsEmpty() )
519*b1cdbd2cSJim Jagielski {
520*b1cdbd2cSJim Jagielski SvxMSDffImportData& rImportData = *(SvxMSDffImportData*)pData;
521*b1cdbd2cSJim Jagielski SvxMSDffImportRec* pImpRec = new SvxMSDffImportRec;
522*b1cdbd2cSJim Jagielski
523*b1cdbd2cSJim Jagielski // fill Import Record with data
524*b1cdbd2cSJim Jagielski pImpRec->nShapeId = rObjData.nShapeId;
525*b1cdbd2cSJim Jagielski pImpRec->eShapeType = rObjData.eShapeType;
526*b1cdbd2cSJim Jagielski
527*b1cdbd2cSJim Jagielski rObjData.bClientAnchor = maShapeRecords.SeekToContent( rSt,
528*b1cdbd2cSJim Jagielski DFF_msofbtClientAnchor,
529*b1cdbd2cSJim Jagielski SEEK_FROM_CURRENT_AND_RESTART );
530*b1cdbd2cSJim Jagielski if( rObjData.bClientAnchor )
531*b1cdbd2cSJim Jagielski ProcessClientAnchor( rSt,
532*b1cdbd2cSJim Jagielski maShapeRecords.Current()->nRecLen,
533*b1cdbd2cSJim Jagielski pImpRec->pClientAnchorBuffer, pImpRec->nClientAnchorLen );
534*b1cdbd2cSJim Jagielski
535*b1cdbd2cSJim Jagielski rObjData.bClientData = maShapeRecords.SeekToContent( rSt,
536*b1cdbd2cSJim Jagielski DFF_msofbtClientData,
537*b1cdbd2cSJim Jagielski SEEK_FROM_CURRENT_AND_RESTART );
538*b1cdbd2cSJim Jagielski if( rObjData.bClientData )
539*b1cdbd2cSJim Jagielski ProcessClientData( rSt,
540*b1cdbd2cSJim Jagielski maShapeRecords.Current()->nRecLen,
541*b1cdbd2cSJim Jagielski pImpRec->pClientDataBuffer, pImpRec->nClientDataLen );
542*b1cdbd2cSJim Jagielski
543*b1cdbd2cSJim Jagielski
544*b1cdbd2cSJim Jagielski // process user (== Winword) defined parameters in 0xF122 record
545*b1cdbd2cSJim Jagielski // #i84783# - set special value to determine, if property is provided or not.
546*b1cdbd2cSJim Jagielski pImpRec->nLayoutInTableCell = 0xFFFFFFFF;
547*b1cdbd2cSJim Jagielski if( maShapeRecords.SeekToContent( rSt,
548*b1cdbd2cSJim Jagielski DFF_msofbtUDefProp,
549*b1cdbd2cSJim Jagielski SEEK_FROM_CURRENT_AND_RESTART )
550*b1cdbd2cSJim Jagielski && maShapeRecords.Current()->nRecLen )
551*b1cdbd2cSJim Jagielski {
552*b1cdbd2cSJim Jagielski sal_uInt32 nBytesLeft = maShapeRecords.Current()->nRecLen;
553*b1cdbd2cSJim Jagielski sal_uInt32 nUDData;
554*b1cdbd2cSJim Jagielski sal_uInt16 nPID;
555*b1cdbd2cSJim Jagielski while( 5 < nBytesLeft )
556*b1cdbd2cSJim Jagielski {
557*b1cdbd2cSJim Jagielski rSt >> nPID;
558*b1cdbd2cSJim Jagielski if ( rSt.GetError() != 0 )
559*b1cdbd2cSJim Jagielski break;
560*b1cdbd2cSJim Jagielski rSt >> nUDData;
561*b1cdbd2cSJim Jagielski switch( nPID )
562*b1cdbd2cSJim Jagielski {
563*b1cdbd2cSJim Jagielski case 0x038F: pImpRec->nXAlign = nUDData; break;
564*b1cdbd2cSJim Jagielski case 0x0390: pImpRec->nXRelTo = nUDData; break;
565*b1cdbd2cSJim Jagielski case 0x0391: pImpRec->nYAlign = nUDData; break;
566*b1cdbd2cSJim Jagielski case 0x0392: pImpRec->nYRelTo = nUDData; break;
567*b1cdbd2cSJim Jagielski case 0x03BF: pImpRec->nLayoutInTableCell = nUDData; break;
568*b1cdbd2cSJim Jagielski }
569*b1cdbd2cSJim Jagielski if ( rSt.GetError() != 0 )
570*b1cdbd2cSJim Jagielski break;
571*b1cdbd2cSJim Jagielski pImpRec->bHasUDefProp = sal_True;
572*b1cdbd2cSJim Jagielski nBytesLeft -= 6;
573*b1cdbd2cSJim Jagielski }
574*b1cdbd2cSJim Jagielski }
575*b1cdbd2cSJim Jagielski
576*b1cdbd2cSJim Jagielski // Textrahmen, auch Title oder Outline
577*b1cdbd2cSJim Jagielski sal_uInt32 nTextId = GetPropertyValue( DFF_Prop_lTxid, 0 );
578*b1cdbd2cSJim Jagielski if( nTextId )
579*b1cdbd2cSJim Jagielski {
580*b1cdbd2cSJim Jagielski SfxItemSet aSet( pSdrModel->GetItemPool() );
581*b1cdbd2cSJim Jagielski
582*b1cdbd2cSJim Jagielski //Originally anything that as a mso_sptTextBox was created as a
583*b1cdbd2cSJim Jagielski //textbox, this was changed to be created as a simple
584*b1cdbd2cSJim Jagielski //rect to keep impress happy. For the rest of us we'd like to turn
585*b1cdbd2cSJim Jagielski //it back into a textbox again.
586*b1cdbd2cSJim Jagielski sal_Bool bIsSimpleDrawingTextBox = (pImpRec->eShapeType == mso_sptTextBox);
587*b1cdbd2cSJim Jagielski if (!bIsSimpleDrawingTextBox)
588*b1cdbd2cSJim Jagielski {
589*b1cdbd2cSJim Jagielski //Either
590*b1cdbd2cSJim Jagielski //a) its a simple text object or
591*b1cdbd2cSJim Jagielski //b) its a rectangle with text and square wrapping.
592*b1cdbd2cSJim Jagielski bIsSimpleDrawingTextBox =
593*b1cdbd2cSJim Jagielski (
594*b1cdbd2cSJim Jagielski (pImpRec->eShapeType == mso_sptTextSimple) ||
595*b1cdbd2cSJim Jagielski (
596*b1cdbd2cSJim Jagielski (pImpRec->eShapeType == mso_sptRectangle)
597*b1cdbd2cSJim Jagielski // && (eWrapMode == mso_wrapSquare)
598*b1cdbd2cSJim Jagielski && ShapeHasText(pImpRec->nShapeId, rObjData.rSpHd.GetRecBegFilePos() )
599*b1cdbd2cSJim Jagielski )
600*b1cdbd2cSJim Jagielski );
601*b1cdbd2cSJim Jagielski }
602*b1cdbd2cSJim Jagielski
603*b1cdbd2cSJim Jagielski // Distance of Textbox to it's surrounding Autoshape
604*b1cdbd2cSJim Jagielski sal_Int32 nTextLeft = GetPropertyValue( DFF_Prop_dxTextLeft, 91440L);
605*b1cdbd2cSJim Jagielski sal_Int32 nTextRight = GetPropertyValue( DFF_Prop_dxTextRight, 91440L );
606*b1cdbd2cSJim Jagielski sal_Int32 nTextTop = GetPropertyValue( DFF_Prop_dyTextTop, 45720L );
607*b1cdbd2cSJim Jagielski sal_Int32 nTextBottom = GetPropertyValue( DFF_Prop_dyTextBottom, 45720L );
608*b1cdbd2cSJim Jagielski
609*b1cdbd2cSJim Jagielski ScaleEmu( nTextLeft );
610*b1cdbd2cSJim Jagielski ScaleEmu( nTextRight );
611*b1cdbd2cSJim Jagielski ScaleEmu( nTextTop );
612*b1cdbd2cSJim Jagielski ScaleEmu( nTextBottom );
613*b1cdbd2cSJim Jagielski
614*b1cdbd2cSJim Jagielski sal_Int32 nTextRotationAngle=0;
615*b1cdbd2cSJim Jagielski bool bVerticalText = false;
616*b1cdbd2cSJim Jagielski if ( IsProperty( DFF_Prop_txflTextFlow ) )
617*b1cdbd2cSJim Jagielski {
618*b1cdbd2cSJim Jagielski MSO_TextFlow eTextFlow = (MSO_TextFlow)(GetPropertyValue(
619*b1cdbd2cSJim Jagielski DFF_Prop_txflTextFlow) & 0xFFFF);
620*b1cdbd2cSJim Jagielski switch( eTextFlow )
621*b1cdbd2cSJim Jagielski {
622*b1cdbd2cSJim Jagielski case mso_txflBtoT:
623*b1cdbd2cSJim Jagielski nTextRotationAngle = 9000;
624*b1cdbd2cSJim Jagielski break;
625*b1cdbd2cSJim Jagielski case mso_txflVertN:
626*b1cdbd2cSJim Jagielski case mso_txflTtoBN:
627*b1cdbd2cSJim Jagielski nTextRotationAngle = 27000;
628*b1cdbd2cSJim Jagielski break;
629*b1cdbd2cSJim Jagielski case mso_txflTtoBA:
630*b1cdbd2cSJim Jagielski bVerticalText = true;
631*b1cdbd2cSJim Jagielski break;
632*b1cdbd2cSJim Jagielski case mso_txflHorzA:
633*b1cdbd2cSJim Jagielski bVerticalText = true;
634*b1cdbd2cSJim Jagielski nTextRotationAngle = 9000;
635*b1cdbd2cSJim Jagielski case mso_txflHorzN:
636*b1cdbd2cSJim Jagielski default :
637*b1cdbd2cSJim Jagielski break;
638*b1cdbd2cSJim Jagielski }
639*b1cdbd2cSJim Jagielski }
640*b1cdbd2cSJim Jagielski
641*b1cdbd2cSJim Jagielski if (nTextRotationAngle)
642*b1cdbd2cSJim Jagielski {
643*b1cdbd2cSJim Jagielski while (nTextRotationAngle > 360000)
644*b1cdbd2cSJim Jagielski nTextRotationAngle-=9000;
645*b1cdbd2cSJim Jagielski switch (nTextRotationAngle)
646*b1cdbd2cSJim Jagielski {
647*b1cdbd2cSJim Jagielski case 9000:
648*b1cdbd2cSJim Jagielski {
649*b1cdbd2cSJim Jagielski long nWidth = rTextRect.GetWidth();
650*b1cdbd2cSJim Jagielski rTextRect.Right() = rTextRect.Left() + rTextRect.GetHeight();
651*b1cdbd2cSJim Jagielski rTextRect.Bottom() = rTextRect.Top() + nWidth;
652*b1cdbd2cSJim Jagielski
653*b1cdbd2cSJim Jagielski sal_Int32 nOldTextLeft = nTextLeft;
654*b1cdbd2cSJim Jagielski sal_Int32 nOldTextRight = nTextRight;
655*b1cdbd2cSJim Jagielski sal_Int32 nOldTextTop = nTextTop;
656*b1cdbd2cSJim Jagielski sal_Int32 nOldTextBottom = nTextBottom;
657*b1cdbd2cSJim Jagielski
658*b1cdbd2cSJim Jagielski nTextLeft = nOldTextBottom;
659*b1cdbd2cSJim Jagielski nTextRight = nOldTextTop;
660*b1cdbd2cSJim Jagielski nTextTop = nOldTextLeft;
661*b1cdbd2cSJim Jagielski nTextBottom = nOldTextRight;
662*b1cdbd2cSJim Jagielski }
663*b1cdbd2cSJim Jagielski break;
664*b1cdbd2cSJim Jagielski case 27000:
665*b1cdbd2cSJim Jagielski {
666*b1cdbd2cSJim Jagielski long nWidth = rTextRect.GetWidth();
667*b1cdbd2cSJim Jagielski rTextRect.Right() = rTextRect.Left() + rTextRect.GetHeight();
668*b1cdbd2cSJim Jagielski rTextRect.Bottom() = rTextRect.Top() + nWidth;
669*b1cdbd2cSJim Jagielski
670*b1cdbd2cSJim Jagielski sal_Int32 nOldTextLeft = nTextLeft;
671*b1cdbd2cSJim Jagielski sal_Int32 nOldTextRight = nTextRight;
672*b1cdbd2cSJim Jagielski sal_Int32 nOldTextTop = nTextTop;
673*b1cdbd2cSJim Jagielski sal_Int32 nOldTextBottom = nTextBottom;
674*b1cdbd2cSJim Jagielski
675*b1cdbd2cSJim Jagielski nTextLeft = nOldTextTop;
676*b1cdbd2cSJim Jagielski nTextRight = nOldTextBottom;
677*b1cdbd2cSJim Jagielski nTextTop = nOldTextRight;
678*b1cdbd2cSJim Jagielski nTextBottom = nOldTextLeft;
679*b1cdbd2cSJim Jagielski }
680*b1cdbd2cSJim Jagielski break;
681*b1cdbd2cSJim Jagielski default:
682*b1cdbd2cSJim Jagielski break;
683*b1cdbd2cSJim Jagielski }
684*b1cdbd2cSJim Jagielski }
685*b1cdbd2cSJim Jagielski
686*b1cdbd2cSJim Jagielski if (bIsSimpleDrawingTextBox)
687*b1cdbd2cSJim Jagielski {
688*b1cdbd2cSJim Jagielski SdrObject::Free( pObj );
689*b1cdbd2cSJim Jagielski pObj = new SdrRectObj(OBJ_TEXT, rTextRect);
690*b1cdbd2cSJim Jagielski }
691*b1cdbd2cSJim Jagielski
692*b1cdbd2cSJim Jagielski // Die vertikalen Absatzeinrueckungen sind im BoundRect mit drin,
693*b1cdbd2cSJim Jagielski // hier rausrechnen
694*b1cdbd2cSJim Jagielski Rectangle aNewRect(rTextRect);
695*b1cdbd2cSJim Jagielski aNewRect.Bottom() -= nTextTop + nTextBottom;
696*b1cdbd2cSJim Jagielski aNewRect.Right() -= nTextLeft + nTextRight;
697*b1cdbd2cSJim Jagielski
698*b1cdbd2cSJim Jagielski // Nur falls es eine einfache Textbox ist, darf der Writer
699*b1cdbd2cSJim Jagielski // das Objekt durch einen Rahmen ersetzen, ansonsten
700*b1cdbd2cSJim Jagielski if( bIsSimpleDrawingTextBox )
701*b1cdbd2cSJim Jagielski {
702*b1cdbd2cSJim Jagielski SvxMSDffShapeInfo aTmpRec( 0, pImpRec->nShapeId );
703*b1cdbd2cSJim Jagielski aTmpRec.bSortByShapeId = sal_True;
704*b1cdbd2cSJim Jagielski
705*b1cdbd2cSJim Jagielski sal_uInt16 nFound;
706*b1cdbd2cSJim Jagielski if( GetShapeInfos()->Seek_Entry( &aTmpRec, &nFound ) )
707*b1cdbd2cSJim Jagielski {
708*b1cdbd2cSJim Jagielski SvxMSDffShapeInfo& rInfo = *GetShapeInfos()->GetObject(nFound);
709*b1cdbd2cSJim Jagielski pImpRec->bReplaceByFly = rInfo.bReplaceByFly;
710*b1cdbd2cSJim Jagielski pImpRec->bLastBoxInChain = rInfo.bLastBoxInChain;
711*b1cdbd2cSJim Jagielski }
712*b1cdbd2cSJim Jagielski }
713*b1cdbd2cSJim Jagielski
714*b1cdbd2cSJim Jagielski if( bIsSimpleDrawingTextBox )
715*b1cdbd2cSJim Jagielski ApplyAttributes( rSt, aSet, rObjData );
716*b1cdbd2cSJim Jagielski
717*b1cdbd2cSJim Jagielski bool bFitText = false;
718*b1cdbd2cSJim Jagielski if (GetPropertyValue(DFF_Prop_FitTextToShape) & 2)
719*b1cdbd2cSJim Jagielski {
720*b1cdbd2cSJim Jagielski aSet.Put( SdrTextAutoGrowHeightItem( sal_True ) );
721*b1cdbd2cSJim Jagielski aSet.Put( SdrTextMinFrameHeightItem(
722*b1cdbd2cSJim Jagielski aNewRect.Bottom() - aNewRect.Top() ) );
723*b1cdbd2cSJim Jagielski aSet.Put( SdrTextMinFrameWidthItem(
724*b1cdbd2cSJim Jagielski aNewRect.Right() - aNewRect.Left() ) );
725*b1cdbd2cSJim Jagielski bFitText = true;
726*b1cdbd2cSJim Jagielski }
727*b1cdbd2cSJim Jagielski else
728*b1cdbd2cSJim Jagielski {
729*b1cdbd2cSJim Jagielski aSet.Put( SdrTextAutoGrowHeightItem( sal_False ) );
730*b1cdbd2cSJim Jagielski aSet.Put( SdrTextAutoGrowWidthItem( sal_False ) );
731*b1cdbd2cSJim Jagielski }
732*b1cdbd2cSJim Jagielski
733*b1cdbd2cSJim Jagielski switch ( (MSO_WrapMode)
734*b1cdbd2cSJim Jagielski GetPropertyValue( DFF_Prop_WrapText, mso_wrapSquare ) )
735*b1cdbd2cSJim Jagielski {
736*b1cdbd2cSJim Jagielski case mso_wrapNone :
737*b1cdbd2cSJim Jagielski aSet.Put( SdrTextAutoGrowWidthItem( sal_True ) );
738*b1cdbd2cSJim Jagielski pImpRec->bAutoWidth = true;
739*b1cdbd2cSJim Jagielski break;
740*b1cdbd2cSJim Jagielski case mso_wrapByPoints :
741*b1cdbd2cSJim Jagielski aSet.Put( SdrTextContourFrameItem( sal_True ) );
742*b1cdbd2cSJim Jagielski break;
743*b1cdbd2cSJim Jagielski default:
744*b1cdbd2cSJim Jagielski ;
745*b1cdbd2cSJim Jagielski }
746*b1cdbd2cSJim Jagielski
747*b1cdbd2cSJim Jagielski // Abstaende an den Raendern der Textbox setzen
748*b1cdbd2cSJim Jagielski aSet.Put( SdrTextLeftDistItem( nTextLeft ) );
749*b1cdbd2cSJim Jagielski aSet.Put( SdrTextRightDistItem( nTextRight ) );
750*b1cdbd2cSJim Jagielski aSet.Put( SdrTextUpperDistItem( nTextTop ) );
751*b1cdbd2cSJim Jagielski aSet.Put( SdrTextLowerDistItem( nTextBottom ) );
752*b1cdbd2cSJim Jagielski pImpRec->nDxTextLeft = nTextLeft;
753*b1cdbd2cSJim Jagielski pImpRec->nDyTextTop = nTextTop;
754*b1cdbd2cSJim Jagielski pImpRec->nDxTextRight = nTextRight;
755*b1cdbd2cSJim Jagielski pImpRec->nDyTextBottom = nTextBottom;
756*b1cdbd2cSJim Jagielski
757*b1cdbd2cSJim Jagielski // --> SJ 2009-03-06 : taking the correct default (which is mso_anchorTop)
758*b1cdbd2cSJim Jagielski MSO_Anchor eTextAnchor =
759*b1cdbd2cSJim Jagielski (MSO_Anchor)GetPropertyValue( DFF_Prop_anchorText, mso_anchorTop );
760*b1cdbd2cSJim Jagielski
761*b1cdbd2cSJim Jagielski SdrTextVertAdjust eTVA = bVerticalText
762*b1cdbd2cSJim Jagielski ? SDRTEXTVERTADJUST_BLOCK
763*b1cdbd2cSJim Jagielski : SDRTEXTVERTADJUST_CENTER;
764*b1cdbd2cSJim Jagielski SdrTextHorzAdjust eTHA = bVerticalText
765*b1cdbd2cSJim Jagielski ? SDRTEXTHORZADJUST_CENTER
766*b1cdbd2cSJim Jagielski : SDRTEXTHORZADJUST_BLOCK;
767*b1cdbd2cSJim Jagielski
768*b1cdbd2cSJim Jagielski switch( eTextAnchor )
769*b1cdbd2cSJim Jagielski {
770*b1cdbd2cSJim Jagielski case mso_anchorTop:
771*b1cdbd2cSJim Jagielski {
772*b1cdbd2cSJim Jagielski if ( bVerticalText )
773*b1cdbd2cSJim Jagielski eTHA = SDRTEXTHORZADJUST_RIGHT;
774*b1cdbd2cSJim Jagielski else
775*b1cdbd2cSJim Jagielski eTVA = SDRTEXTVERTADJUST_TOP;
776*b1cdbd2cSJim Jagielski }
777*b1cdbd2cSJim Jagielski break;
778*b1cdbd2cSJim Jagielski case mso_anchorTopCentered:
779*b1cdbd2cSJim Jagielski {
780*b1cdbd2cSJim Jagielski if ( bVerticalText )
781*b1cdbd2cSJim Jagielski eTHA = SDRTEXTHORZADJUST_RIGHT;
782*b1cdbd2cSJim Jagielski else
783*b1cdbd2cSJim Jagielski eTVA = SDRTEXTVERTADJUST_TOP;
784*b1cdbd2cSJim Jagielski }
785*b1cdbd2cSJim Jagielski break;
786*b1cdbd2cSJim Jagielski case mso_anchorMiddle:
787*b1cdbd2cSJim Jagielski break;
788*b1cdbd2cSJim Jagielski case mso_anchorMiddleCentered:
789*b1cdbd2cSJim Jagielski break;
790*b1cdbd2cSJim Jagielski case mso_anchorBottom:
791*b1cdbd2cSJim Jagielski {
792*b1cdbd2cSJim Jagielski if ( bVerticalText )
793*b1cdbd2cSJim Jagielski eTHA = SDRTEXTHORZADJUST_LEFT;
794*b1cdbd2cSJim Jagielski else
795*b1cdbd2cSJim Jagielski eTVA = SDRTEXTVERTADJUST_BOTTOM;
796*b1cdbd2cSJim Jagielski }
797*b1cdbd2cSJim Jagielski break;
798*b1cdbd2cSJim Jagielski case mso_anchorBottomCentered:
799*b1cdbd2cSJim Jagielski {
800*b1cdbd2cSJim Jagielski if ( bVerticalText )
801*b1cdbd2cSJim Jagielski eTHA = SDRTEXTHORZADJUST_LEFT;
802*b1cdbd2cSJim Jagielski else
803*b1cdbd2cSJim Jagielski eTVA = SDRTEXTVERTADJUST_BOTTOM;
804*b1cdbd2cSJim Jagielski }
805*b1cdbd2cSJim Jagielski break;
806*b1cdbd2cSJim Jagielski /*
807*b1cdbd2cSJim Jagielski case mso_anchorTopBaseline:
808*b1cdbd2cSJim Jagielski case mso_anchorBottomBaseline:
809*b1cdbd2cSJim Jagielski case mso_anchorTopCenteredBaseline:
810*b1cdbd2cSJim Jagielski case mso_anchorBottomCenteredBaseline:
811*b1cdbd2cSJim Jagielski break;
812*b1cdbd2cSJim Jagielski */
813*b1cdbd2cSJim Jagielski default:
814*b1cdbd2cSJim Jagielski ;
815*b1cdbd2cSJim Jagielski }
816*b1cdbd2cSJim Jagielski
817*b1cdbd2cSJim Jagielski aSet.Put( SdrTextVertAdjustItem( eTVA ) );
818*b1cdbd2cSJim Jagielski aSet.Put( SdrTextHorzAdjustItem( eTHA ) );
819*b1cdbd2cSJim Jagielski
820*b1cdbd2cSJim Jagielski if (pObj != NULL)
821*b1cdbd2cSJim Jagielski {
822*b1cdbd2cSJim Jagielski pObj->SetMergedItemSet(aSet);
823*b1cdbd2cSJim Jagielski pObj->SetModel(pSdrModel);
824*b1cdbd2cSJim Jagielski
825*b1cdbd2cSJim Jagielski if (bVerticalText && dynamic_cast< SdrTextObj* >( pObj ) )
826*b1cdbd2cSJim Jagielski dynamic_cast< SdrTextObj* >( pObj )->SetVerticalWriting(sal_True);
827*b1cdbd2cSJim Jagielski
828*b1cdbd2cSJim Jagielski if ( bIsSimpleDrawingTextBox )
829*b1cdbd2cSJim Jagielski {
830*b1cdbd2cSJim Jagielski if ( nTextRotationAngle )
831*b1cdbd2cSJim Jagielski {
832*b1cdbd2cSJim Jagielski long nMinWH = rTextRect.GetWidth() < rTextRect.GetHeight() ?
833*b1cdbd2cSJim Jagielski rTextRect.GetWidth() : rTextRect.GetHeight();
834*b1cdbd2cSJim Jagielski nMinWH /= 2;
835*b1cdbd2cSJim Jagielski Point aPivot(rTextRect.TopLeft());
836*b1cdbd2cSJim Jagielski aPivot.X() += nMinWH;
837*b1cdbd2cSJim Jagielski aPivot.Y() += nMinWH;
838*b1cdbd2cSJim Jagielski double a = nTextRotationAngle * nPi180;
839*b1cdbd2cSJim Jagielski pObj->NbcRotate(aPivot, nTextRotationAngle, sin(a), cos(a));
840*b1cdbd2cSJim Jagielski }
841*b1cdbd2cSJim Jagielski }
842*b1cdbd2cSJim Jagielski
843*b1cdbd2cSJim Jagielski if ( ( ( rObjData.nSpFlags & SP_FFLIPV ) || mnFix16Angle || nTextRotationAngle ) && dynamic_cast< SdrObjCustomShape* >( pObj ) )
844*b1cdbd2cSJim Jagielski {
845*b1cdbd2cSJim Jagielski SdrObjCustomShape* pCustomShape = dynamic_cast< SdrObjCustomShape* >( pObj );
846*b1cdbd2cSJim Jagielski
847*b1cdbd2cSJim Jagielski double fExtraTextRotation = 0.0;
848*b1cdbd2cSJim Jagielski if ( mnFix16Angle && !( GetPropertyValue( DFF_Prop_FitTextToShape ) & 4 ) )
849*b1cdbd2cSJim Jagielski { // text is already rotated, we have to take back the object rotation if DFF_Prop_RotateText is false
850*b1cdbd2cSJim Jagielski fExtraTextRotation = -mnFix16Angle;
851*b1cdbd2cSJim Jagielski }
852*b1cdbd2cSJim Jagielski if ( rObjData.nSpFlags & SP_FFLIPV ) // sj: in ppt the text is flipped, whereas in word the text
853*b1cdbd2cSJim Jagielski { // remains unchanged, so we have to take back the flipping here
854*b1cdbd2cSJim Jagielski fExtraTextRotation += 18000.0; // because our core will flip text if the shape is flipped.
855*b1cdbd2cSJim Jagielski }
856*b1cdbd2cSJim Jagielski fExtraTextRotation += nTextRotationAngle;
857*b1cdbd2cSJim Jagielski if ( !::basegfx::fTools::equalZero( fExtraTextRotation ) )
858*b1cdbd2cSJim Jagielski {
859*b1cdbd2cSJim Jagielski fExtraTextRotation /= 100.0;
860*b1cdbd2cSJim Jagielski SdrCustomShapeGeometryItem aGeometryItem( (SdrCustomShapeGeometryItem&)pCustomShape->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) );
861*b1cdbd2cSJim Jagielski const rtl::OUString sTextRotateAngle( RTL_CONSTASCII_USTRINGPARAM ( "TextRotateAngle" ) );
862*b1cdbd2cSJim Jagielski com::sun::star::beans::PropertyValue aPropVal;
863*b1cdbd2cSJim Jagielski aPropVal.Name = sTextRotateAngle;
864*b1cdbd2cSJim Jagielski aPropVal.Value <<= fExtraTextRotation;
865*b1cdbd2cSJim Jagielski aGeometryItem.SetPropertyValue( aPropVal );
866*b1cdbd2cSJim Jagielski pCustomShape->SetMergedItem( aGeometryItem );
867*b1cdbd2cSJim Jagielski }
868*b1cdbd2cSJim Jagielski }
869*b1cdbd2cSJim Jagielski else if ( mnFix16Angle )
870*b1cdbd2cSJim Jagielski {
871*b1cdbd2cSJim Jagielski // rotate text with shape ?
872*b1cdbd2cSJim Jagielski double a = mnFix16Angle * nPi180;
873*b1cdbd2cSJim Jagielski pObj->NbcRotate( rObjData.aBoundRect.Center(), mnFix16Angle,
874*b1cdbd2cSJim Jagielski sin( a ), cos( a ) );
875*b1cdbd2cSJim Jagielski }
876*b1cdbd2cSJim Jagielski }
877*b1cdbd2cSJim Jagielski }
878*b1cdbd2cSJim Jagielski else if( !pObj )
879*b1cdbd2cSJim Jagielski {
880*b1cdbd2cSJim Jagielski // simple rectangular objects are ignored by ImportObj() :-(
881*b1cdbd2cSJim Jagielski // this is OK for Draw but not for Calc and Writer
882*b1cdbd2cSJim Jagielski // cause here these objects have a default border
883*b1cdbd2cSJim Jagielski pObj = new SdrRectObj(rTextRect);
884*b1cdbd2cSJim Jagielski pObj->SetModel( pSdrModel );
885*b1cdbd2cSJim Jagielski SfxItemSet aSet( pSdrModel->GetItemPool() );
886*b1cdbd2cSJim Jagielski ApplyAttributes( rSt, aSet, rObjData );
887*b1cdbd2cSJim Jagielski
888*b1cdbd2cSJim Jagielski const SfxPoolItem* pPoolItem=NULL;
889*b1cdbd2cSJim Jagielski SfxItemState eState = aSet.GetItemState( XATTR_FILLCOLOR,
890*b1cdbd2cSJim Jagielski sal_False, &pPoolItem );
891*b1cdbd2cSJim Jagielski if( SFX_ITEM_DEFAULT == eState )
892*b1cdbd2cSJim Jagielski aSet.Put( XFillColorItem( String(),
893*b1cdbd2cSJim Jagielski Color( mnDefaultColor ) ) );
894*b1cdbd2cSJim Jagielski pObj->SetMergedItemSet(aSet);
895*b1cdbd2cSJim Jagielski }
896*b1cdbd2cSJim Jagielski
897*b1cdbd2cSJim Jagielski //Means that fBehindDocument is set
898*b1cdbd2cSJim Jagielski if (GetPropertyValue(DFF_Prop_fPrint) & 0x20)
899*b1cdbd2cSJim Jagielski pImpRec->bDrawHell = sal_True;
900*b1cdbd2cSJim Jagielski else
901*b1cdbd2cSJim Jagielski pImpRec->bDrawHell = sal_False;
902*b1cdbd2cSJim Jagielski if (GetPropertyValue(DFF_Prop_fPrint) & 0x02)
903*b1cdbd2cSJim Jagielski pImpRec->bHidden = sal_True;
904*b1cdbd2cSJim Jagielski pImpRec->nNextShapeId = GetPropertyValue( DFF_Prop_hspNext, 0 );
905*b1cdbd2cSJim Jagielski
906*b1cdbd2cSJim Jagielski if ( nTextId )
907*b1cdbd2cSJim Jagielski {
908*b1cdbd2cSJim Jagielski pImpRec->aTextId.nTxBxS = (sal_uInt16)( nTextId >> 16 );
909*b1cdbd2cSJim Jagielski pImpRec->aTextId.nSequence = (sal_uInt16)nTextId;
910*b1cdbd2cSJim Jagielski }
911*b1cdbd2cSJim Jagielski
912*b1cdbd2cSJim Jagielski pImpRec->nDxWrapDistLeft = GetPropertyValue(
913*b1cdbd2cSJim Jagielski DFF_Prop_dxWrapDistLeft, 114935L ) / 635L;
914*b1cdbd2cSJim Jagielski pImpRec->nDyWrapDistTop = GetPropertyValue(
915*b1cdbd2cSJim Jagielski DFF_Prop_dyWrapDistTop, 0 ) / 635L;
916*b1cdbd2cSJim Jagielski pImpRec->nDxWrapDistRight = GetPropertyValue(
917*b1cdbd2cSJim Jagielski DFF_Prop_dxWrapDistRight, 114935L ) / 635L;
918*b1cdbd2cSJim Jagielski pImpRec->nDyWrapDistBottom = GetPropertyValue(
919*b1cdbd2cSJim Jagielski DFF_Prop_dyWrapDistBottom, 0 ) / 635L;
920*b1cdbd2cSJim Jagielski // 16.16 fraction times total image width or height, as appropriate.
921*b1cdbd2cSJim Jagielski
922*b1cdbd2cSJim Jagielski if (SeekToContent(DFF_Prop_pWrapPolygonVertices, rSt))
923*b1cdbd2cSJim Jagielski {
924*b1cdbd2cSJim Jagielski delete pImpRec->pWrapPolygon;
925*b1cdbd2cSJim Jagielski pImpRec->pWrapPolygon = NULL;
926*b1cdbd2cSJim Jagielski
927*b1cdbd2cSJim Jagielski sal_uInt16 nNumElemVert, nNumElemMemVert, nElemSizeVert;
928*b1cdbd2cSJim Jagielski rSt >> nNumElemVert >> nNumElemMemVert >> nElemSizeVert;
929*b1cdbd2cSJim Jagielski if (nNumElemVert && ((nElemSizeVert == 8) || (nElemSizeVert == 4)))
930*b1cdbd2cSJim Jagielski {
931*b1cdbd2cSJim Jagielski pImpRec->pWrapPolygon = new Polygon(nNumElemVert);
932*b1cdbd2cSJim Jagielski for (sal_uInt16 i = 0; i < nNumElemVert; ++i)
933*b1cdbd2cSJim Jagielski {
934*b1cdbd2cSJim Jagielski sal_Int32 nX, nY;
935*b1cdbd2cSJim Jagielski if (nElemSizeVert == 8)
936*b1cdbd2cSJim Jagielski rSt >> nX >> nY;
937*b1cdbd2cSJim Jagielski else
938*b1cdbd2cSJim Jagielski {
939*b1cdbd2cSJim Jagielski sal_Int16 nSmallX, nSmallY;
940*b1cdbd2cSJim Jagielski rSt >> nSmallX >> nSmallY;
941*b1cdbd2cSJim Jagielski nX = nSmallX;
942*b1cdbd2cSJim Jagielski nY = nSmallY;
943*b1cdbd2cSJim Jagielski }
944*b1cdbd2cSJim Jagielski (*(pImpRec->pWrapPolygon))[i].X() = nX;
945*b1cdbd2cSJim Jagielski (*(pImpRec->pWrapPolygon))[i].Y() = nY;
946*b1cdbd2cSJim Jagielski }
947*b1cdbd2cSJim Jagielski }
948*b1cdbd2cSJim Jagielski }
949*b1cdbd2cSJim Jagielski
950*b1cdbd2cSJim Jagielski pImpRec->nCropFromTop = GetPropertyValue(
951*b1cdbd2cSJim Jagielski DFF_Prop_cropFromTop, 0 );
952*b1cdbd2cSJim Jagielski pImpRec->nCropFromBottom = GetPropertyValue(
953*b1cdbd2cSJim Jagielski DFF_Prop_cropFromBottom, 0 );
954*b1cdbd2cSJim Jagielski pImpRec->nCropFromLeft = GetPropertyValue(
955*b1cdbd2cSJim Jagielski DFF_Prop_cropFromLeft, 0 );
956*b1cdbd2cSJim Jagielski pImpRec->nCropFromRight = GetPropertyValue(
957*b1cdbd2cSJim Jagielski DFF_Prop_cropFromRight, 0 );
958*b1cdbd2cSJim Jagielski
959*b1cdbd2cSJim Jagielski sal_uInt32 nLineFlags = GetPropertyValue( DFF_Prop_fNoLineDrawDash );
960*b1cdbd2cSJim Jagielski if ( !IsHardAttribute( DFF_Prop_fLine ) &&
961*b1cdbd2cSJim Jagielski pImpRec->eShapeType == mso_sptPictureFrame )
962*b1cdbd2cSJim Jagielski {
963*b1cdbd2cSJim Jagielski nLineFlags &= ~0x08;
964*b1cdbd2cSJim Jagielski }
965*b1cdbd2cSJim Jagielski pImpRec->eLineStyle = (nLineFlags & 8)
966*b1cdbd2cSJim Jagielski ? (MSO_LineStyle)GetPropertyValue(
967*b1cdbd2cSJim Jagielski DFF_Prop_lineStyle,
968*b1cdbd2cSJim Jagielski mso_lineSimple )
969*b1cdbd2cSJim Jagielski : (MSO_LineStyle)USHRT_MAX;
970*b1cdbd2cSJim Jagielski
971*b1cdbd2cSJim Jagielski pImpRec->nFlags = rObjData.nSpFlags;
972*b1cdbd2cSJim Jagielski
973*b1cdbd2cSJim Jagielski if( pImpRec->nShapeId )
974*b1cdbd2cSJim Jagielski {
975*b1cdbd2cSJim Jagielski // Import-Record-Liste ergaenzen
976*b1cdbd2cSJim Jagielski pImpRec->pObj = pObj;
977*b1cdbd2cSJim Jagielski rImportData.aRecords.Insert( pImpRec );
978*b1cdbd2cSJim Jagielski
979*b1cdbd2cSJim Jagielski // Eintrag in Z-Order-Liste um Zeiger auf dieses Objekt ergaenzen
980*b1cdbd2cSJim Jagielski /*Only store objects which are not deep inside the tree*/
981*b1cdbd2cSJim Jagielski if( ( rObjData.nCalledByGroup == 0 )
982*b1cdbd2cSJim Jagielski ||
983*b1cdbd2cSJim Jagielski ( (rObjData.nSpFlags & SP_FGROUP)
984*b1cdbd2cSJim Jagielski && (rObjData.nCalledByGroup < 2) )
985*b1cdbd2cSJim Jagielski )
986*b1cdbd2cSJim Jagielski StoreShapeOrder( pImpRec->nShapeId,
987*b1cdbd2cSJim Jagielski ( ( (sal_uLong)pImpRec->aTextId.nTxBxS ) << 16 )
988*b1cdbd2cSJim Jagielski + pImpRec->aTextId.nSequence, pObj );
989*b1cdbd2cSJim Jagielski }
990*b1cdbd2cSJim Jagielski else
991*b1cdbd2cSJim Jagielski delete pImpRec;
992*b1cdbd2cSJim Jagielski }
993*b1cdbd2cSJim Jagielski
994*b1cdbd2cSJim Jagielski sal_uInt32 nBufferSize = GetPropertyValue( DFF_Prop_pihlShape );
995*b1cdbd2cSJim Jagielski if( (0 < nBufferSize) && (nBufferSize <= 0xFFFF) && SeekToContent( DFF_Prop_pihlShape, rSt ) )
996*b1cdbd2cSJim Jagielski {
997*b1cdbd2cSJim Jagielski SvMemoryStream aMemStream;
998*b1cdbd2cSJim Jagielski String aStrURL;
999*b1cdbd2cSJim Jagielski struct HyperLinksTable hlStr;
1000*b1cdbd2cSJim Jagielski sal_uInt16 mnRawRecId,mnRawRecSize;
1001*b1cdbd2cSJim Jagielski aMemStream << sal_uInt16( 0 ) << static_cast< sal_uInt16 >( nBufferSize );
1002*b1cdbd2cSJim Jagielski
1003*b1cdbd2cSJim Jagielski // copy from DFF stream to memory stream
1004*b1cdbd2cSJim Jagielski ::std::vector< sal_uInt8 > aBuffer( nBufferSize );
1005*b1cdbd2cSJim Jagielski sal_uInt8* pnData = &aBuffer.front();
1006*b1cdbd2cSJim Jagielski sal_uInt8 mnStreamSize;
1007*b1cdbd2cSJim Jagielski if( pnData && rSt.Read( pnData, nBufferSize ) == nBufferSize )
1008*b1cdbd2cSJim Jagielski {
1009*b1cdbd2cSJim Jagielski aMemStream.Write( pnData, nBufferSize );
1010*b1cdbd2cSJim Jagielski aMemStream.Seek( STREAM_SEEK_TO_END );
1011*b1cdbd2cSJim Jagielski mnStreamSize = aMemStream.Tell();
1012*b1cdbd2cSJim Jagielski aMemStream.Seek( STREAM_SEEK_TO_BEGIN );
1013*b1cdbd2cSJim Jagielski bool bRet = 4 <= mnStreamSize;
1014*b1cdbd2cSJim Jagielski if( bRet )
1015*b1cdbd2cSJim Jagielski aMemStream >> mnRawRecId >> mnRawRecSize;
1016*b1cdbd2cSJim Jagielski SwDocShell* pDocShell = rReader.mpDocShell;
1017*b1cdbd2cSJim Jagielski if(pDocShell)
1018*b1cdbd2cSJim Jagielski {
1019*b1cdbd2cSJim Jagielski rReader.ReadEmbeddedData( aMemStream, pDocShell, hlStr);
1020*b1cdbd2cSJim Jagielski }
1021*b1cdbd2cSJim Jagielski }
1022*b1cdbd2cSJim Jagielski
1023*b1cdbd2cSJim Jagielski if(pObj && hlStr.hLinkAddr.Len() > 0)
1024*b1cdbd2cSJim Jagielski {
1025*b1cdbd2cSJim Jagielski SwMacroInfo* pInfo = GetMacroInfo( pObj, true );
1026*b1cdbd2cSJim Jagielski if( pInfo )
1027*b1cdbd2cSJim Jagielski {
1028*b1cdbd2cSJim Jagielski pInfo->SetShapeId( rObjData.nShapeId );
1029*b1cdbd2cSJim Jagielski pInfo->SetHlink( hlStr.hLinkAddr );
1030*b1cdbd2cSJim Jagielski if(hlStr.tarFrm.Len() > 0)
1031*b1cdbd2cSJim Jagielski pInfo->SetTarFrm( hlStr.tarFrm );
1032*b1cdbd2cSJim Jagielski String aNameStr = GetPropertyString( DFF_Prop_wzName, rSt );
1033*b1cdbd2cSJim Jagielski if(aNameStr.Len() > 0)
1034*b1cdbd2cSJim Jagielski pInfo->SetName( aNameStr );
1035*b1cdbd2cSJim Jagielski }
1036*b1cdbd2cSJim Jagielski }
1037*b1cdbd2cSJim Jagielski }
1038*b1cdbd2cSJim Jagielski
1039*b1cdbd2cSJim Jagielski return pObj;
1040*b1cdbd2cSJim Jagielski }
1041*b1cdbd2cSJim Jagielski
1042*b1cdbd2cSJim Jagielski /***************************************************************************
1043*b1cdbd2cSJim Jagielski # Spezial FastSave - Attribute
1044*b1cdbd2cSJim Jagielski #**************************************************************************/
1045*b1cdbd2cSJim Jagielski
Read_StyleCode(sal_uInt16,const sal_uInt8 * pData,short nLen)1046*b1cdbd2cSJim Jagielski void SwWW8ImplReader::Read_StyleCode( sal_uInt16, const sal_uInt8* pData, short nLen )
1047*b1cdbd2cSJim Jagielski {
1048*b1cdbd2cSJim Jagielski if (nLen < 0)
1049*b1cdbd2cSJim Jagielski {
1050*b1cdbd2cSJim Jagielski bCpxStyle = false;
1051*b1cdbd2cSJim Jagielski return;
1052*b1cdbd2cSJim Jagielski }
1053*b1cdbd2cSJim Jagielski sal_uInt16 nColl = 0;
1054*b1cdbd2cSJim Jagielski if (pWwFib->GetFIBVersion() <= ww::eWW2)
1055*b1cdbd2cSJim Jagielski nColl = *pData;
1056*b1cdbd2cSJim Jagielski else
1057*b1cdbd2cSJim Jagielski nColl = SVBT16ToShort(pData);
1058*b1cdbd2cSJim Jagielski if (nColl < nColls)
1059*b1cdbd2cSJim Jagielski {
1060*b1cdbd2cSJim Jagielski SetTxtFmtCollAndListLevel( *pPaM, pCollA[nColl] );
1061*b1cdbd2cSJim Jagielski bCpxStyle = true;
1062*b1cdbd2cSJim Jagielski }
1063*b1cdbd2cSJim Jagielski }
1064*b1cdbd2cSJim Jagielski
1065*b1cdbd2cSJim Jagielski // Read_Majority ist fuer Majority ( 103 ) und Majority50 ( 108 )
Read_Majority(sal_uInt16,const sal_uInt8 *,short)1066*b1cdbd2cSJim Jagielski void SwWW8ImplReader::Read_Majority( sal_uInt16, const sal_uInt8* , short )
1067*b1cdbd2cSJim Jagielski {
1068*b1cdbd2cSJim Jagielski }
1069*b1cdbd2cSJim Jagielski
1070*b1cdbd2cSJim Jagielski //-----------------------------------------
1071*b1cdbd2cSJim Jagielski // Stack
1072*b1cdbd2cSJim Jagielski //-----------------------------------------
NewAttr(const SwPosition & rPos,const SfxPoolItem & rAttr)1073*b1cdbd2cSJim Jagielski void SwWW8FltControlStack::NewAttr(const SwPosition& rPos,
1074*b1cdbd2cSJim Jagielski const SfxPoolItem& rAttr)
1075*b1cdbd2cSJim Jagielski {
1076*b1cdbd2cSJim Jagielski ASSERT(RES_TXTATR_FIELD != rAttr.Which(), "probably don't want to put"
1077*b1cdbd2cSJim Jagielski "fields into the control stack");
1078*b1cdbd2cSJim Jagielski ASSERT(RES_TXTATR_ANNOTATION != rAttr.Which(), "probably don't want to put"
1079*b1cdbd2cSJim Jagielski "annotations into the control stack");
1080*b1cdbd2cSJim Jagielski ASSERT(RES_TXTATR_INPUTFIELD != rAttr.Which(), "probably don't want to put"
1081*b1cdbd2cSJim Jagielski "input fields into the control stack");
1082*b1cdbd2cSJim Jagielski ASSERT(RES_FLTR_REDLINE != rAttr.Which(), "probably don't want to put"
1083*b1cdbd2cSJim Jagielski "redlines into the control stack");
1084*b1cdbd2cSJim Jagielski SwFltControlStack::NewAttr(rPos, rAttr);
1085*b1cdbd2cSJim Jagielski }
1086*b1cdbd2cSJim Jagielski
SetAttr(const SwPosition & rPos,sal_uInt16 nAttrId,sal_Bool bTstEnde,long nHand,sal_Bool)1087*b1cdbd2cSJim Jagielski void SwWW8FltControlStack::SetAttr(const SwPosition& rPos, sal_uInt16 nAttrId,
1088*b1cdbd2cSJim Jagielski sal_Bool bTstEnde, long nHand, sal_Bool )
1089*b1cdbd2cSJim Jagielski {
1090*b1cdbd2cSJim Jagielski //Doing a textbox, and using the control stack only as a temporary
1091*b1cdbd2cSJim Jagielski //collection point for properties which will are not to be set into
1092*b1cdbd2cSJim Jagielski //the real document
1093*b1cdbd2cSJim Jagielski if (rReader.pPlcxMan && rReader.pPlcxMan->GetDoingDrawTextBox())
1094*b1cdbd2cSJim Jagielski {
1095*b1cdbd2cSJim Jagielski sal_uInt16 nCnt = static_cast< sal_uInt16 >(Count());
1096*b1cdbd2cSJim Jagielski for (sal_uInt16 i=0; i < nCnt; ++i)
1097*b1cdbd2cSJim Jagielski {
1098*b1cdbd2cSJim Jagielski SwFltStackEntry* pEntry = (*this)[i];
1099*b1cdbd2cSJim Jagielski if (nAttrId == pEntry->pAttr->Which())
1100*b1cdbd2cSJim Jagielski {
1101*b1cdbd2cSJim Jagielski DeleteAndDestroy(i--);
1102*b1cdbd2cSJim Jagielski --nCnt;
1103*b1cdbd2cSJim Jagielski }
1104*b1cdbd2cSJim Jagielski }
1105*b1cdbd2cSJim Jagielski }
1106*b1cdbd2cSJim Jagielski else //Normal case, set the attribute into the document
1107*b1cdbd2cSJim Jagielski SwFltControlStack::SetAttr(rPos, nAttrId, bTstEnde, nHand);
1108*b1cdbd2cSJim Jagielski }
1109*b1cdbd2cSJim Jagielski
GetListFirstLineIndent(const SwNumFmt & rFmt)1110*b1cdbd2cSJim Jagielski long GetListFirstLineIndent(const SwNumFmt &rFmt)
1111*b1cdbd2cSJim Jagielski {
1112*b1cdbd2cSJim Jagielski ASSERT( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_WIDTH_AND_POSITION,
1113*b1cdbd2cSJim Jagielski "<GetListFirstLineIndent> - misusage: position-and-space-mode does not equal LABEL_WIDTH_AND_POSITION" );
1114*b1cdbd2cSJim Jagielski
1115*b1cdbd2cSJim Jagielski SvxAdjust eAdj = rFmt.GetNumAdjust();
1116*b1cdbd2cSJim Jagielski long nReverseListIndented;
1117*b1cdbd2cSJim Jagielski if (eAdj == SVX_ADJUST_RIGHT)
1118*b1cdbd2cSJim Jagielski nReverseListIndented = -rFmt.GetCharTextDistance();
1119*b1cdbd2cSJim Jagielski else if (eAdj == SVX_ADJUST_CENTER)
1120*b1cdbd2cSJim Jagielski nReverseListIndented = rFmt.GetFirstLineOffset()/2;
1121*b1cdbd2cSJim Jagielski else
1122*b1cdbd2cSJim Jagielski nReverseListIndented = rFmt.GetFirstLineOffset();
1123*b1cdbd2cSJim Jagielski return nReverseListIndented;
1124*b1cdbd2cSJim Jagielski }
1125*b1cdbd2cSJim Jagielski
lcl_GetTrueMargin(const SvxLRSpaceItem & rLR,const SwNumFmt & rFmt,long & rFirstLinePos)1126*b1cdbd2cSJim Jagielski long lcl_GetTrueMargin(const SvxLRSpaceItem &rLR, const SwNumFmt &rFmt,
1127*b1cdbd2cSJim Jagielski long &rFirstLinePos)
1128*b1cdbd2cSJim Jagielski {
1129*b1cdbd2cSJim Jagielski ASSERT( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_WIDTH_AND_POSITION,
1130*b1cdbd2cSJim Jagielski "<lcl_GetTrueMargin> - misusage: position-and-space-mode does not equal LABEL_WIDTH_AND_POSITION" );
1131*b1cdbd2cSJim Jagielski
1132*b1cdbd2cSJim Jagielski const long nBodyIndent = rLR.GetTxtLeft();
1133*b1cdbd2cSJim Jagielski const long nFirstLineDiff = rLR.GetTxtFirstLineOfst();
1134*b1cdbd2cSJim Jagielski rFirstLinePos = nBodyIndent + nFirstLineDiff;
1135*b1cdbd2cSJim Jagielski
1136*b1cdbd2cSJim Jagielski const long nPseudoListBodyIndent = rFmt.GetAbsLSpace();
1137*b1cdbd2cSJim Jagielski const long nReverseListIndented = GetListFirstLineIndent(rFmt);
1138*b1cdbd2cSJim Jagielski long nExtraListIndent = nPseudoListBodyIndent + nReverseListIndented;
1139*b1cdbd2cSJim Jagielski
1140*b1cdbd2cSJim Jagielski return nExtraListIndent > 0 ? nExtraListIndent : 0;
1141*b1cdbd2cSJim Jagielski }
1142*b1cdbd2cSJim Jagielski
SyncIndentWithList(SvxLRSpaceItem & rLR,const SwNumFmt & rFmt,const bool bFirstLineOfstSet,const bool bLeftIndentSet)1143*b1cdbd2cSJim Jagielski void SyncIndentWithList( SvxLRSpaceItem &rLR,
1144*b1cdbd2cSJim Jagielski const SwNumFmt &rFmt,
1145*b1cdbd2cSJim Jagielski const bool bFirstLineOfstSet,
1146*b1cdbd2cSJim Jagielski const bool bLeftIndentSet )
1147*b1cdbd2cSJim Jagielski {
1148*b1cdbd2cSJim Jagielski if ( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
1149*b1cdbd2cSJim Jagielski {
1150*b1cdbd2cSJim Jagielski long nWantedFirstLinePos;
1151*b1cdbd2cSJim Jagielski long nExtraListIndent = lcl_GetTrueMargin(rLR, rFmt, nWantedFirstLinePos);
1152*b1cdbd2cSJim Jagielski rLR.SetTxtLeft(nWantedFirstLinePos - nExtraListIndent);
1153*b1cdbd2cSJim Jagielski rLR.SetTxtFirstLineOfst(0);
1154*b1cdbd2cSJim Jagielski }
1155*b1cdbd2cSJim Jagielski else if ( rFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT )
1156*b1cdbd2cSJim Jagielski {
1157*b1cdbd2cSJim Jagielski if ( !bFirstLineOfstSet && bLeftIndentSet &&
1158*b1cdbd2cSJim Jagielski rFmt.GetFirstLineIndent() != 0 )
1159*b1cdbd2cSJim Jagielski {
1160*b1cdbd2cSJim Jagielski rLR.SetTxtFirstLineOfst( rFmt.GetFirstLineIndent() );
1161*b1cdbd2cSJim Jagielski }
1162*b1cdbd2cSJim Jagielski else if ( bFirstLineOfstSet && !bLeftIndentSet &&
1163*b1cdbd2cSJim Jagielski rFmt.GetIndentAt() != 0 )
1164*b1cdbd2cSJim Jagielski {
1165*b1cdbd2cSJim Jagielski rLR.SetTxtLeft( rFmt.GetIndentAt() );
1166*b1cdbd2cSJim Jagielski }
1167*b1cdbd2cSJim Jagielski else if (!bFirstLineOfstSet && !bLeftIndentSet )
1168*b1cdbd2cSJim Jagielski {
1169*b1cdbd2cSJim Jagielski if ( rFmt.GetFirstLineIndent() != 0 )
1170*b1cdbd2cSJim Jagielski {
1171*b1cdbd2cSJim Jagielski rLR.SetTxtFirstLineOfst( rFmt.GetFirstLineIndent() );
1172*b1cdbd2cSJim Jagielski }
1173*b1cdbd2cSJim Jagielski if ( rFmt.GetIndentAt() != 0 )
1174*b1cdbd2cSJim Jagielski {
1175*b1cdbd2cSJim Jagielski rLR.SetTxtLeft( rFmt.GetIndentAt() );
1176*b1cdbd2cSJim Jagielski }
1177*b1cdbd2cSJim Jagielski }
1178*b1cdbd2cSJim Jagielski }
1179*b1cdbd2cSJim Jagielski }
1180*b1cdbd2cSJim Jagielski
GetNumFmtFromStack(const SwPosition & rPos,const SwTxtNode & rTxtNode)1181*b1cdbd2cSJim Jagielski const SwNumFmt* SwWW8FltControlStack::GetNumFmtFromStack(const SwPosition &rPos,
1182*b1cdbd2cSJim Jagielski const SwTxtNode &rTxtNode)
1183*b1cdbd2cSJim Jagielski {
1184*b1cdbd2cSJim Jagielski const SwNumFmt *pRet = 0;
1185*b1cdbd2cSJim Jagielski const SfxPoolItem *pItem = GetStackAttr(rPos, RES_FLTR_NUMRULE);
1186*b1cdbd2cSJim Jagielski if (pItem && rTxtNode.GetNumRule())
1187*b1cdbd2cSJim Jagielski {
1188*b1cdbd2cSJim Jagielski String sName(((SfxStringItem*)pItem)->GetValue());
1189*b1cdbd2cSJim Jagielski if (rTxtNode.IsCountedInList())
1190*b1cdbd2cSJim Jagielski {
1191*b1cdbd2cSJim Jagielski const SwNumRule *pRule = pDoc->FindNumRulePtr(sName);
1192*b1cdbd2cSJim Jagielski sal_uInt8 nLvl = static_cast< sal_uInt8 >(rTxtNode.GetActualListLevel());
1193*b1cdbd2cSJim Jagielski pRet = &(pRule->Get(nLvl));
1194*b1cdbd2cSJim Jagielski }
1195*b1cdbd2cSJim Jagielski }
1196*b1cdbd2cSJim Jagielski return pRet;
1197*b1cdbd2cSJim Jagielski }
1198*b1cdbd2cSJim Jagielski
1199*b1cdbd2cSJim Jagielski //Modify here for #119405, by easyfan, 2012-05-24
GetCurrAttrCP() const1200*b1cdbd2cSJim Jagielski sal_Int32 SwWW8FltControlStack::GetCurrAttrCP() const
1201*b1cdbd2cSJim Jagielski {
1202*b1cdbd2cSJim Jagielski return rReader.GetCurrAttrCP();
1203*b1cdbd2cSJim Jagielski }
IsParaEndInCPs(sal_Int32 nStart,sal_Int32 nEnd,bool bSdOD) const1204*b1cdbd2cSJim Jagielski bool SwWW8FltControlStack::IsParaEndInCPs(sal_Int32 nStart,sal_Int32 nEnd,bool bSdOD) const
1205*b1cdbd2cSJim Jagielski {
1206*b1cdbd2cSJim Jagielski return rReader.IsParaEndInCPs(nStart,nEnd,bSdOD);
1207*b1cdbd2cSJim Jagielski }
1208*b1cdbd2cSJim Jagielski //End of modification, by easyfan
1209*b1cdbd2cSJim Jagielski //Modify for #119405 by chengjh, 2012-08-16
1210*b1cdbd2cSJim Jagielski //Clear the para end position recorded in reader intermittently for the least impact on loading performance
ClearParaEndPosition()1211*b1cdbd2cSJim Jagielski void SwWW8FltControlStack::ClearParaEndPosition()
1212*b1cdbd2cSJim Jagielski {
1213*b1cdbd2cSJim Jagielski if ( Count() != 0 )
1214*b1cdbd2cSJim Jagielski return;
1215*b1cdbd2cSJim Jagielski
1216*b1cdbd2cSJim Jagielski rReader.ClearParaEndPosition();
1217*b1cdbd2cSJim Jagielski }
CheckSdOD(sal_Int32 nStart,sal_Int32 nEnd)1218*b1cdbd2cSJim Jagielski bool SwWW8FltControlStack::CheckSdOD(sal_Int32 nStart,sal_Int32 nEnd)
1219*b1cdbd2cSJim Jagielski {
1220*b1cdbd2cSJim Jagielski return rReader.IsParaEndInCPs(nStart,nEnd);
1221*b1cdbd2cSJim Jagielski }
1222*b1cdbd2cSJim Jagielski //End
1223*b1cdbd2cSJim Jagielski
SetAttrInDoc(const SwPosition & rTmpPos,SwFltStackEntry * pEntry)1224*b1cdbd2cSJim Jagielski void SwWW8ReferencedFltEndStack::SetAttrInDoc( const SwPosition& rTmpPos,
1225*b1cdbd2cSJim Jagielski SwFltStackEntry* pEntry )
1226*b1cdbd2cSJim Jagielski {
1227*b1cdbd2cSJim Jagielski switch( pEntry->pAttr->Which() )
1228*b1cdbd2cSJim Jagielski {
1229*b1cdbd2cSJim Jagielski case RES_FLTR_BOOKMARK:
1230*b1cdbd2cSJim Jagielski {
1231*b1cdbd2cSJim Jagielski // suppress insertion of bookmark, which is recognized as an internal bookmark used for table-of-content
1232*b1cdbd2cSJim Jagielski // and which is not referenced.
1233*b1cdbd2cSJim Jagielski bool bInsertBookmarkIntoDoc = true;
1234*b1cdbd2cSJim Jagielski
1235*b1cdbd2cSJim Jagielski SwFltBookmark* pFltBookmark = dynamic_cast<SwFltBookmark*>(pEntry->pAttr);
1236*b1cdbd2cSJim Jagielski if ( pFltBookmark != 0 && pFltBookmark->IsTOCBookmark() )
1237*b1cdbd2cSJim Jagielski {
1238*b1cdbd2cSJim Jagielski const String& rName = pFltBookmark->GetName();
1239*b1cdbd2cSJim Jagielski ::std::set< String, SwWW8::ltstr >::const_iterator aResult = aReferencedTOCBookmarks.find(rName);
1240*b1cdbd2cSJim Jagielski if ( aResult == aReferencedTOCBookmarks.end() )
1241*b1cdbd2cSJim Jagielski {
1242*b1cdbd2cSJim Jagielski bInsertBookmarkIntoDoc = false;
1243*b1cdbd2cSJim Jagielski }
1244*b1cdbd2cSJim Jagielski }
1245*b1cdbd2cSJim Jagielski if ( bInsertBookmarkIntoDoc )
1246*b1cdbd2cSJim Jagielski {
1247*b1cdbd2cSJim Jagielski SwFltEndStack::SetAttrInDoc( rTmpPos, pEntry );
1248*b1cdbd2cSJim Jagielski }
1249*b1cdbd2cSJim Jagielski break;
1250*b1cdbd2cSJim Jagielski }
1251*b1cdbd2cSJim Jagielski default:
1252*b1cdbd2cSJim Jagielski SwFltEndStack::SetAttrInDoc( rTmpPos, pEntry );
1253*b1cdbd2cSJim Jagielski break;
1254*b1cdbd2cSJim Jagielski }
1255*b1cdbd2cSJim Jagielski
1256*b1cdbd2cSJim Jagielski }
1257*b1cdbd2cSJim Jagielski
SetAttrInDoc(const SwPosition & rTmpPos,SwFltStackEntry * pEntry)1258*b1cdbd2cSJim Jagielski void SwWW8FltControlStack::SetAttrInDoc(const SwPosition& rTmpPos,
1259*b1cdbd2cSJim Jagielski SwFltStackEntry* pEntry)
1260*b1cdbd2cSJim Jagielski {
1261*b1cdbd2cSJim Jagielski switch( pEntry->pAttr->Which() )
1262*b1cdbd2cSJim Jagielski {
1263*b1cdbd2cSJim Jagielski case RES_LR_SPACE:
1264*b1cdbd2cSJim Jagielski {
1265*b1cdbd2cSJim Jagielski /*
1266*b1cdbd2cSJim Jagielski Loop over the affect nodes and
1267*b1cdbd2cSJim Jagielski a) convert the word style absolute indent to indent relative
1268*b1cdbd2cSJim Jagielski to any numbering indent active on the nodes
1269*b1cdbd2cSJim Jagielski b) adjust the writer style tabstops relative to the old
1270*b1cdbd2cSJim Jagielski paragraph indent to be relative to the new paragraph indent
1271*b1cdbd2cSJim Jagielski */
1272*b1cdbd2cSJim Jagielski using namespace sw::util;
1273*b1cdbd2cSJim Jagielski SwPaM aRegion(rTmpPos);
1274*b1cdbd2cSJim Jagielski if (pEntry->MakeRegion(pDoc, aRegion, false))
1275*b1cdbd2cSJim Jagielski {
1276*b1cdbd2cSJim Jagielski SvxLRSpaceItem aNewLR( *(SvxLRSpaceItem*)pEntry->pAttr );
1277*b1cdbd2cSJim Jagielski sal_uLong nStart = aRegion.Start()->nNode.GetIndex();
1278*b1cdbd2cSJim Jagielski sal_uLong nEnd = aRegion.End()->nNode.GetIndex();
1279*b1cdbd2cSJim Jagielski for(; nStart <= nEnd; ++nStart)
1280*b1cdbd2cSJim Jagielski {
1281*b1cdbd2cSJim Jagielski SwNode* pNode = pDoc->GetNodes()[ nStart ];
1282*b1cdbd2cSJim Jagielski if (!pNode || !pNode->IsTxtNode())
1283*b1cdbd2cSJim Jagielski continue;
1284*b1cdbd2cSJim Jagielski
1285*b1cdbd2cSJim Jagielski SwCntntNode* pNd = (SwCntntNode*)pNode;
1286*b1cdbd2cSJim Jagielski SvxLRSpaceItem aOldLR = (const SvxLRSpaceItem&)pNd->GetAttr(RES_LR_SPACE);
1287*b1cdbd2cSJim Jagielski
1288*b1cdbd2cSJim Jagielski SwTxtNode *pTxtNode = (SwTxtNode*)pNode;
1289*b1cdbd2cSJim Jagielski
1290*b1cdbd2cSJim Jagielski const SwNumFmt *pNum = 0;
1291*b1cdbd2cSJim Jagielski pNum = GetNumFmtFromStack( *aRegion.GetPoint(), *pTxtNode );
1292*b1cdbd2cSJim Jagielski if (!pNum)
1293*b1cdbd2cSJim Jagielski {
1294*b1cdbd2cSJim Jagielski pNum = GetNumFmtFromTxtNode(*pTxtNode);
1295*b1cdbd2cSJim Jagielski }
1296*b1cdbd2cSJim Jagielski
1297*b1cdbd2cSJim Jagielski if ( pNum )
1298*b1cdbd2cSJim Jagielski {
1299*b1cdbd2cSJim Jagielski const bool bFirstLineIndentSet =
1300*b1cdbd2cSJim Jagielski ( rReader.maTxtNodesHavingFirstLineOfstSet.end() !=
1301*b1cdbd2cSJim Jagielski rReader.maTxtNodesHavingFirstLineOfstSet.find( pNode ) );
1302*b1cdbd2cSJim Jagielski const bool bLeftIndentSet =
1303*b1cdbd2cSJim Jagielski ( rReader.maTxtNodesHavingLeftIndentSet.end() !=
1304*b1cdbd2cSJim Jagielski rReader.maTxtNodesHavingLeftIndentSet.find( pNode ) );
1305*b1cdbd2cSJim Jagielski SyncIndentWithList( aNewLR, *pNum,
1306*b1cdbd2cSJim Jagielski bFirstLineIndentSet,
1307*b1cdbd2cSJim Jagielski bLeftIndentSet );
1308*b1cdbd2cSJim Jagielski }
1309*b1cdbd2cSJim Jagielski
1310*b1cdbd2cSJim Jagielski if (aNewLR == aOldLR)
1311*b1cdbd2cSJim Jagielski continue;
1312*b1cdbd2cSJim Jagielski
1313*b1cdbd2cSJim Jagielski pNd->SetAttr(aNewLR);
1314*b1cdbd2cSJim Jagielski
1315*b1cdbd2cSJim Jagielski }
1316*b1cdbd2cSJim Jagielski }
1317*b1cdbd2cSJim Jagielski }
1318*b1cdbd2cSJim Jagielski break;
1319*b1cdbd2cSJim Jagielski
1320*b1cdbd2cSJim Jagielski case RES_TXTATR_FIELD:
1321*b1cdbd2cSJim Jagielski ASSERT(!this, "What is a field doing in the control stack,"
1322*b1cdbd2cSJim Jagielski "probably should have been in the endstack");
1323*b1cdbd2cSJim Jagielski break;
1324*b1cdbd2cSJim Jagielski
1325*b1cdbd2cSJim Jagielski case RES_TXTATR_ANNOTATION:
1326*b1cdbd2cSJim Jagielski ASSERT(!this, "What is a annotation doing in the control stack,"
1327*b1cdbd2cSJim Jagielski "probably should have been in the endstack");
1328*b1cdbd2cSJim Jagielski break;
1329*b1cdbd2cSJim Jagielski
1330*b1cdbd2cSJim Jagielski case RES_TXTATR_INPUTFIELD:
1331*b1cdbd2cSJim Jagielski ASSERT(!this, "What is a input field doing in the control stack,"
1332*b1cdbd2cSJim Jagielski "probably should have been in the endstack");
1333*b1cdbd2cSJim Jagielski break;
1334*b1cdbd2cSJim Jagielski
1335*b1cdbd2cSJim Jagielski case RES_TXTATR_INETFMT:
1336*b1cdbd2cSJim Jagielski {
1337*b1cdbd2cSJim Jagielski SwPaM aRegion(rTmpPos);
1338*b1cdbd2cSJim Jagielski if (pEntry->MakeRegion(pDoc, aRegion, false))
1339*b1cdbd2cSJim Jagielski {
1340*b1cdbd2cSJim Jagielski SwFrmFmt *pFrm;
1341*b1cdbd2cSJim Jagielski //If we have just one single inline graphic then
1342*b1cdbd2cSJim Jagielski //don't insert a field for the single frame, set
1343*b1cdbd2cSJim Jagielski //the frames hyperlink field attribute directly.
1344*b1cdbd2cSJim Jagielski if (0 != (pFrm = rReader.ContainsSingleInlineGraphic(aRegion)))
1345*b1cdbd2cSJim Jagielski {
1346*b1cdbd2cSJim Jagielski const SwFmtINetFmt *pAttr = (const SwFmtINetFmt *)
1347*b1cdbd2cSJim Jagielski pEntry->pAttr;
1348*b1cdbd2cSJim Jagielski SwFmtURL aURL;
1349*b1cdbd2cSJim Jagielski aURL.SetURL(pAttr->GetValue(), false);
1350*b1cdbd2cSJim Jagielski aURL.SetTargetFrameName(pAttr->GetTargetFrame());
1351*b1cdbd2cSJim Jagielski pFrm->SetFmtAttr(aURL);
1352*b1cdbd2cSJim Jagielski }
1353*b1cdbd2cSJim Jagielski else
1354*b1cdbd2cSJim Jagielski {
1355*b1cdbd2cSJim Jagielski pDoc->InsertPoolItem(aRegion, *pEntry->pAttr, 0);
1356*b1cdbd2cSJim Jagielski }
1357*b1cdbd2cSJim Jagielski }
1358*b1cdbd2cSJim Jagielski }
1359*b1cdbd2cSJim Jagielski break;
1360*b1cdbd2cSJim Jagielski default:
1361*b1cdbd2cSJim Jagielski SwFltControlStack::SetAttrInDoc(rTmpPos, pEntry);
1362*b1cdbd2cSJim Jagielski break;
1363*b1cdbd2cSJim Jagielski }
1364*b1cdbd2cSJim Jagielski }
1365*b1cdbd2cSJim Jagielski
GetFmtAttr(const SwPosition & rPos,sal_uInt16 nWhich)1366*b1cdbd2cSJim Jagielski const SfxPoolItem* SwWW8FltControlStack::GetFmtAttr(const SwPosition& rPos,
1367*b1cdbd2cSJim Jagielski sal_uInt16 nWhich)
1368*b1cdbd2cSJim Jagielski {
1369*b1cdbd2cSJim Jagielski const SfxPoolItem *pItem = GetStackAttr(rPos, nWhich);
1370*b1cdbd2cSJim Jagielski if (!pItem)
1371*b1cdbd2cSJim Jagielski {
1372*b1cdbd2cSJim Jagielski SwCntntNode const*const pNd = rPos.nNode.GetNode().GetCntntNode();
1373*b1cdbd2cSJim Jagielski if (!pNd)
1374*b1cdbd2cSJim Jagielski pItem = &pDoc->GetAttrPool().GetDefaultItem(nWhich);
1375*b1cdbd2cSJim Jagielski else
1376*b1cdbd2cSJim Jagielski {
1377*b1cdbd2cSJim Jagielski /*
1378*b1cdbd2cSJim Jagielski If we're hunting for the indent on a paragraph and need to use the
1379*b1cdbd2cSJim Jagielski parent style indent, then return the indent in msword format, and
1380*b1cdbd2cSJim Jagielski not writer format, because that's the style that the filter works
1381*b1cdbd2cSJim Jagielski in (naturally)
1382*b1cdbd2cSJim Jagielski */
1383*b1cdbd2cSJim Jagielski if (nWhich == RES_LR_SPACE)
1384*b1cdbd2cSJim Jagielski {
1385*b1cdbd2cSJim Jagielski SfxItemState eState = SFX_ITEM_DEFAULT;
1386*b1cdbd2cSJim Jagielski if (const SfxItemSet *pSet = pNd->GetpSwAttrSet())
1387*b1cdbd2cSJim Jagielski eState = pSet->GetItemState(RES_LR_SPACE, false);
1388*b1cdbd2cSJim Jagielski if (eState != SFX_ITEM_SET && rReader.pCollA != NULL)
1389*b1cdbd2cSJim Jagielski pItem = &(rReader.pCollA[rReader.nAktColl].maWordLR);
1390*b1cdbd2cSJim Jagielski }
1391*b1cdbd2cSJim Jagielski
1392*b1cdbd2cSJim Jagielski if (!pItem)
1393*b1cdbd2cSJim Jagielski pItem = &pNd->GetAttr(nWhich);
1394*b1cdbd2cSJim Jagielski }
1395*b1cdbd2cSJim Jagielski }
1396*b1cdbd2cSJim Jagielski return pItem;
1397*b1cdbd2cSJim Jagielski }
1398*b1cdbd2cSJim Jagielski
GetStackAttr(const SwPosition & rPos,sal_uInt16 nWhich)1399*b1cdbd2cSJim Jagielski const SfxPoolItem* SwWW8FltControlStack::GetStackAttr(const SwPosition& rPos,
1400*b1cdbd2cSJim Jagielski sal_uInt16 nWhich)
1401*b1cdbd2cSJim Jagielski {
1402*b1cdbd2cSJim Jagielski SwNodeIndex aNode( rPos.nNode, -1 );
1403*b1cdbd2cSJim Jagielski sal_uInt16 nIdx = rPos.nContent.GetIndex();
1404*b1cdbd2cSJim Jagielski
1405*b1cdbd2cSJim Jagielski sal_uInt16 nSize = static_cast< sal_uInt16 >(Count());
1406*b1cdbd2cSJim Jagielski while (nSize)
1407*b1cdbd2cSJim Jagielski {
1408*b1cdbd2cSJim Jagielski const SwFltStackEntry* pEntry = (*this)[ --nSize ];
1409*b1cdbd2cSJim Jagielski if (pEntry->pAttr->Which() == nWhich)
1410*b1cdbd2cSJim Jagielski {
1411*b1cdbd2cSJim Jagielski if ( (pEntry->bLocked) || (
1412*b1cdbd2cSJim Jagielski (pEntry->nMkNode <= aNode) && (pEntry->nPtNode >= aNode) &&
1413*b1cdbd2cSJim Jagielski (pEntry->nMkCntnt <= nIdx) && (pEntry->nPtCntnt >= nIdx) ) )
1414*b1cdbd2cSJim Jagielski {
1415*b1cdbd2cSJim Jagielski return (const SfxPoolItem*)pEntry->pAttr;
1416*b1cdbd2cSJim Jagielski }
1417*b1cdbd2cSJim Jagielski }
1418*b1cdbd2cSJim Jagielski }
1419*b1cdbd2cSJim Jagielski return 0;
1420*b1cdbd2cSJim Jagielski }
1421*b1cdbd2cSJim Jagielski
IsFtnEdnBkmField(const SwFmtFld & rFmtFld,sal_uInt16 & rBkmNo)1422*b1cdbd2cSJim Jagielski bool SwWW8FltRefStack::IsFtnEdnBkmField(
1423*b1cdbd2cSJim Jagielski const SwFmtFld& rFmtFld,
1424*b1cdbd2cSJim Jagielski sal_uInt16& rBkmNo)
1425*b1cdbd2cSJim Jagielski {
1426*b1cdbd2cSJim Jagielski const SwField* pFld = rFmtFld.GetField();
1427*b1cdbd2cSJim Jagielski sal_uInt16 nSubType;
1428*b1cdbd2cSJim Jagielski if(pFld && (RES_GETREFFLD == pFld->Which())
1429*b1cdbd2cSJim Jagielski && ((REF_FOOTNOTE == (nSubType = pFld->GetSubType())) || (REF_ENDNOTE == nSubType))
1430*b1cdbd2cSJim Jagielski && ((SwGetRefField*)pFld)->GetSetRefName().Len())
1431*b1cdbd2cSJim Jagielski {
1432*b1cdbd2cSJim Jagielski const IDocumentMarkAccess* const pMarkAccess = pDoc->getIDocumentMarkAccess();
1433*b1cdbd2cSJim Jagielski IDocumentMarkAccess::const_iterator_t ppBkmk =
1434*b1cdbd2cSJim Jagielski pMarkAccess->findMark( ((SwGetRefField*)pFld)->GetSetRefName() );
1435*b1cdbd2cSJim Jagielski if(ppBkmk != pMarkAccess->getAllMarksEnd())
1436*b1cdbd2cSJim Jagielski {
1437*b1cdbd2cSJim Jagielski // find Sequence No of corresponding Foot-/Endnote
1438*b1cdbd2cSJim Jagielski rBkmNo = ppBkmk - pMarkAccess->getAllMarksBegin();
1439*b1cdbd2cSJim Jagielski return true;
1440*b1cdbd2cSJim Jagielski }
1441*b1cdbd2cSJim Jagielski }
1442*b1cdbd2cSJim Jagielski return false;
1443*b1cdbd2cSJim Jagielski }
1444*b1cdbd2cSJim Jagielski
SetAttrInDoc(const SwPosition & rTmpPos,SwFltStackEntry * pEntry)1445*b1cdbd2cSJim Jagielski void SwWW8FltRefStack::SetAttrInDoc(const SwPosition& rTmpPos,
1446*b1cdbd2cSJim Jagielski SwFltStackEntry* pEntry)
1447*b1cdbd2cSJim Jagielski {
1448*b1cdbd2cSJim Jagielski switch( pEntry->pAttr->Which() )
1449*b1cdbd2cSJim Jagielski {
1450*b1cdbd2cSJim Jagielski /*
1451*b1cdbd2cSJim Jagielski Look up these in our lists of bookmarks that were changed to
1452*b1cdbd2cSJim Jagielski variables, and replace the ref field with a var field, otherwise
1453*b1cdbd2cSJim Jagielski do normal (?) strange stuff
1454*b1cdbd2cSJim Jagielski */
1455*b1cdbd2cSJim Jagielski case RES_TXTATR_FIELD:
1456*b1cdbd2cSJim Jagielski case RES_TXTATR_ANNOTATION:
1457*b1cdbd2cSJim Jagielski case RES_TXTATR_INPUTFIELD:
1458*b1cdbd2cSJim Jagielski {
1459*b1cdbd2cSJim Jagielski SwNodeIndex aIdx(pEntry->nMkNode, 1);
1460*b1cdbd2cSJim Jagielski SwPaM aPaM(aIdx, pEntry->nMkCntnt);
1461*b1cdbd2cSJim Jagielski
1462*b1cdbd2cSJim Jagielski SwFmtFld& rFmtFld = *(SwFmtFld*)pEntry->pAttr;
1463*b1cdbd2cSJim Jagielski SwField* pFld = rFmtFld.GetField();
1464*b1cdbd2cSJim Jagielski
1465*b1cdbd2cSJim Jagielski if (!RefToVar(pFld,pEntry))
1466*b1cdbd2cSJim Jagielski {
1467*b1cdbd2cSJim Jagielski sal_uInt16 nBkmNo;
1468*b1cdbd2cSJim Jagielski if( IsFtnEdnBkmField(rFmtFld, nBkmNo) )
1469*b1cdbd2cSJim Jagielski {
1470*b1cdbd2cSJim Jagielski ::sw::mark::IMark const * const pMark = (pDoc->getIDocumentMarkAccess()->getAllMarksBegin() + nBkmNo)->get();
1471*b1cdbd2cSJim Jagielski
1472*b1cdbd2cSJim Jagielski const SwPosition& rBkMrkPos = pMark->GetMarkPos();
1473*b1cdbd2cSJim Jagielski
1474*b1cdbd2cSJim Jagielski SwTxtNode* pTxt = rBkMrkPos.nNode.GetNode().GetTxtNode();
1475*b1cdbd2cSJim Jagielski if( pTxt && rBkMrkPos.nContent.GetIndex() )
1476*b1cdbd2cSJim Jagielski {
1477*b1cdbd2cSJim Jagielski SwTxtAttr* const pFtn = pTxt->GetTxtAttrForCharAt(
1478*b1cdbd2cSJim Jagielski rBkMrkPos.nContent.GetIndex()-1, RES_TXTATR_FTN );
1479*b1cdbd2cSJim Jagielski if( pFtn )
1480*b1cdbd2cSJim Jagielski {
1481*b1cdbd2cSJim Jagielski sal_uInt16 nRefNo = ((SwTxtFtn*)pFtn)->GetSeqRefNo();
1482*b1cdbd2cSJim Jagielski
1483*b1cdbd2cSJim Jagielski ((SwGetRefField*)pFld)->SetSeqNo( nRefNo );
1484*b1cdbd2cSJim Jagielski
1485*b1cdbd2cSJim Jagielski if( pFtn->GetFtn().IsEndNote() )
1486*b1cdbd2cSJim Jagielski ((SwGetRefField*)pFld)->SetSubType(REF_ENDNOTE);
1487*b1cdbd2cSJim Jagielski }
1488*b1cdbd2cSJim Jagielski }
1489*b1cdbd2cSJim Jagielski }
1490*b1cdbd2cSJim Jagielski }
1491*b1cdbd2cSJim Jagielski
1492*b1cdbd2cSJim Jagielski pDoc->InsertPoolItem(aPaM, *pEntry->pAttr, 0);
1493*b1cdbd2cSJim Jagielski MoveAttrs(*aPaM.GetPoint());
1494*b1cdbd2cSJim Jagielski }
1495*b1cdbd2cSJim Jagielski break;
1496*b1cdbd2cSJim Jagielski case RES_FLTR_TOX:
1497*b1cdbd2cSJim Jagielski SwFltEndStack::SetAttrInDoc(rTmpPos, pEntry);
1498*b1cdbd2cSJim Jagielski break;
1499*b1cdbd2cSJim Jagielski default:
1500*b1cdbd2cSJim Jagielski case RES_FLTR_BOOKMARK:
1501*b1cdbd2cSJim Jagielski ASSERT(!this, "EndStck used with non field, not what we want");
1502*b1cdbd2cSJim Jagielski SwFltEndStack::SetAttrInDoc(rTmpPos, pEntry);
1503*b1cdbd2cSJim Jagielski break;
1504*b1cdbd2cSJim Jagielski }
1505*b1cdbd2cSJim Jagielski }
1506*b1cdbd2cSJim Jagielski
1507*b1cdbd2cSJim Jagielski /*
1508*b1cdbd2cSJim Jagielski For styles we will do our tabstop arithmetic in word style and adjust them to
1509*b1cdbd2cSJim Jagielski writer style after all the styles have been finished and the dust settles as
1510*b1cdbd2cSJim Jagielski to what affects what.
1511*b1cdbd2cSJim Jagielski
1512*b1cdbd2cSJim Jagielski For explicit attributes we turn the adjusted writer tabstops back into 0 based
1513*b1cdbd2cSJim Jagielski word indexes and we'll turn them back into writer indexes when setting them
1514*b1cdbd2cSJim Jagielski into the document. If explicit left indent exist which affects them, then this
1515*b1cdbd2cSJim Jagielski is handled when the explict left indent is set into the document
1516*b1cdbd2cSJim Jagielski */
Read_Tab(sal_uInt16,const sal_uInt8 * pData,short nLen)1517*b1cdbd2cSJim Jagielski void SwWW8ImplReader::Read_Tab(sal_uInt16 , const sal_uInt8* pData, short nLen)
1518*b1cdbd2cSJim Jagielski {
1519*b1cdbd2cSJim Jagielski if (nLen < 0)
1520*b1cdbd2cSJim Jagielski {
1521*b1cdbd2cSJim Jagielski pCtrlStck->SetAttr(*pPaM->GetPoint(), RES_PARATR_TABSTOP);
1522*b1cdbd2cSJim Jagielski return;
1523*b1cdbd2cSJim Jagielski }
1524*b1cdbd2cSJim Jagielski
1525*b1cdbd2cSJim Jagielski short i;
1526*b1cdbd2cSJim Jagielski const sal_uInt8* pDel = pData + 1; // Del - Array
1527*b1cdbd2cSJim Jagielski sal_uInt8 nDel = pData[0];
1528*b1cdbd2cSJim Jagielski const sal_uInt8* pIns = pData + 2*nDel + 2; // Ins - Array
1529*b1cdbd2cSJim Jagielski sal_uInt8 nIns = pData[nDel*2+1];
1530*b1cdbd2cSJim Jagielski WW8_TBD* pTyp = (WW8_TBD*)(pData + 2*nDel + 2*nIns + 2);// Typ - Array
1531*b1cdbd2cSJim Jagielski
1532*b1cdbd2cSJim Jagielski SvxTabStopItem aAttr(0, 0, SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP);
1533*b1cdbd2cSJim Jagielski
1534*b1cdbd2cSJim Jagielski const SwTxtFmtColl* pSty = 0;
1535*b1cdbd2cSJim Jagielski sal_uInt16 nTabBase;
1536*b1cdbd2cSJim Jagielski if (pAktColl) // StyleDef
1537*b1cdbd2cSJim Jagielski {
1538*b1cdbd2cSJim Jagielski nTabBase = pCollA[nAktColl].nBase;
1539*b1cdbd2cSJim Jagielski if (nTabBase < nColls) // Based On
1540*b1cdbd2cSJim Jagielski pSty = (const SwTxtFmtColl*)pCollA[nTabBase].pFmt;
1541*b1cdbd2cSJim Jagielski }
1542*b1cdbd2cSJim Jagielski else
1543*b1cdbd2cSJim Jagielski { // Text
1544*b1cdbd2cSJim Jagielski nTabBase = nAktColl;
1545*b1cdbd2cSJim Jagielski pSty = (const SwTxtFmtColl*)pCollA[nAktColl].pFmt;
1546*b1cdbd2cSJim Jagielski }
1547*b1cdbd2cSJim Jagielski
1548*b1cdbd2cSJim Jagielski bool bFound = false;
1549*b1cdbd2cSJim Jagielski ::std::hash_set<size_t> aLoopWatch;
1550*b1cdbd2cSJim Jagielski while (pSty && !bFound)
1551*b1cdbd2cSJim Jagielski {
1552*b1cdbd2cSJim Jagielski const SfxPoolItem* pTabs;
1553*b1cdbd2cSJim Jagielski bFound = pSty->GetAttrSet().GetItemState(RES_PARATR_TABSTOP, false,
1554*b1cdbd2cSJim Jagielski &pTabs) == SFX_ITEM_SET;
1555*b1cdbd2cSJim Jagielski if( bFound )
1556*b1cdbd2cSJim Jagielski aAttr = *((const SvxTabStopItem*)pTabs);
1557*b1cdbd2cSJim Jagielski else
1558*b1cdbd2cSJim Jagielski {
1559*b1cdbd2cSJim Jagielski
1560*b1cdbd2cSJim Jagielski sal_uInt16 nOldTabBase = nTabBase;
1561*b1cdbd2cSJim Jagielski // If based on another
1562*b1cdbd2cSJim Jagielski if (nTabBase < nColls)
1563*b1cdbd2cSJim Jagielski nTabBase = pCollA[nTabBase].nBase;
1564*b1cdbd2cSJim Jagielski
1565*b1cdbd2cSJim Jagielski if (
1566*b1cdbd2cSJim Jagielski nTabBase < nColls &&
1567*b1cdbd2cSJim Jagielski nOldTabBase != nTabBase &&
1568*b1cdbd2cSJim Jagielski nTabBase != ww::stiNil
1569*b1cdbd2cSJim Jagielski )
1570*b1cdbd2cSJim Jagielski {
1571*b1cdbd2cSJim Jagielski // #i61789: Stop searching when next style is the same as the
1572*b1cdbd2cSJim Jagielski // current one (prevent loop)
1573*b1cdbd2cSJim Jagielski aLoopWatch.insert(reinterpret_cast<size_t>(pSty));
1574*b1cdbd2cSJim Jagielski pSty = (const SwTxtFmtColl*)pCollA[nTabBase].pFmt;
1575*b1cdbd2cSJim Jagielski
1576*b1cdbd2cSJim Jagielski if (aLoopWatch.find(reinterpret_cast<size_t>(pSty)) !=
1577*b1cdbd2cSJim Jagielski aLoopWatch.end())
1578*b1cdbd2cSJim Jagielski pSty = 0;
1579*b1cdbd2cSJim Jagielski }
1580*b1cdbd2cSJim Jagielski else
1581*b1cdbd2cSJim Jagielski pSty = 0; // gib die Suche auf
1582*b1cdbd2cSJim Jagielski }
1583*b1cdbd2cSJim Jagielski }
1584*b1cdbd2cSJim Jagielski
1585*b1cdbd2cSJim Jagielski SvxTabStop aTabStop;
1586*b1cdbd2cSJim Jagielski for (i=0; i < nDel; ++i)
1587*b1cdbd2cSJim Jagielski {
1588*b1cdbd2cSJim Jagielski sal_uInt16 nPos = aAttr.GetPos(SVBT16ToShort(pDel + i*2));
1589*b1cdbd2cSJim Jagielski if( nPos != SVX_TAB_NOTFOUND )
1590*b1cdbd2cSJim Jagielski aAttr.Remove( nPos, 1 );
1591*b1cdbd2cSJim Jagielski }
1592*b1cdbd2cSJim Jagielski
1593*b1cdbd2cSJim Jagielski for (i=0; i < nIns; ++i)
1594*b1cdbd2cSJim Jagielski {
1595*b1cdbd2cSJim Jagielski short nPos = SVBT16ToShort(pIns + i*2);
1596*b1cdbd2cSJim Jagielski aTabStop.GetTabPos() = nPos;
1597*b1cdbd2cSJim Jagielski switch( SVBT8ToByte( pTyp[i].aBits1 ) & 0x7 ) // pTyp[i].jc
1598*b1cdbd2cSJim Jagielski {
1599*b1cdbd2cSJim Jagielski case 0:
1600*b1cdbd2cSJim Jagielski aTabStop.GetAdjustment() = SVX_TAB_ADJUST_LEFT;
1601*b1cdbd2cSJim Jagielski break;
1602*b1cdbd2cSJim Jagielski case 1:
1603*b1cdbd2cSJim Jagielski aTabStop.GetAdjustment() = SVX_TAB_ADJUST_CENTER;
1604*b1cdbd2cSJim Jagielski break;
1605*b1cdbd2cSJim Jagielski case 2:
1606*b1cdbd2cSJim Jagielski aTabStop.GetAdjustment() = SVX_TAB_ADJUST_RIGHT;
1607*b1cdbd2cSJim Jagielski break;
1608*b1cdbd2cSJim Jagielski case 3:
1609*b1cdbd2cSJim Jagielski aTabStop.GetAdjustment() = SVX_TAB_ADJUST_DECIMAL;
1610*b1cdbd2cSJim Jagielski break;
1611*b1cdbd2cSJim Jagielski case 4:
1612*b1cdbd2cSJim Jagielski continue; // ignoriere Bar
1613*b1cdbd2cSJim Jagielski }
1614*b1cdbd2cSJim Jagielski
1615*b1cdbd2cSJim Jagielski switch( SVBT8ToByte( pTyp[i].aBits1 ) >> 3 & 0x7 )
1616*b1cdbd2cSJim Jagielski {
1617*b1cdbd2cSJim Jagielski case 0:
1618*b1cdbd2cSJim Jagielski aTabStop.GetFill() = ' ';
1619*b1cdbd2cSJim Jagielski break;
1620*b1cdbd2cSJim Jagielski case 1:
1621*b1cdbd2cSJim Jagielski aTabStop.GetFill() = '.';
1622*b1cdbd2cSJim Jagielski break;
1623*b1cdbd2cSJim Jagielski case 2:
1624*b1cdbd2cSJim Jagielski aTabStop.GetFill() = '-';
1625*b1cdbd2cSJim Jagielski break;
1626*b1cdbd2cSJim Jagielski case 3:
1627*b1cdbd2cSJim Jagielski case 4:
1628*b1cdbd2cSJim Jagielski aTabStop.GetFill() = '_';
1629*b1cdbd2cSJim Jagielski break;
1630*b1cdbd2cSJim Jagielski }
1631*b1cdbd2cSJim Jagielski
1632*b1cdbd2cSJim Jagielski sal_uInt16 nPos2 = aAttr.GetPos( nPos );
1633*b1cdbd2cSJim Jagielski if (nPos2 != SVX_TAB_NOTFOUND)
1634*b1cdbd2cSJim Jagielski aAttr.Remove(nPos2, 1); // sonst weigert sich das Insert()
1635*b1cdbd2cSJim Jagielski aAttr.Insert(aTabStop);
1636*b1cdbd2cSJim Jagielski }
1637*b1cdbd2cSJim Jagielski
1638*b1cdbd2cSJim Jagielski if (nIns || nDel)
1639*b1cdbd2cSJim Jagielski NewAttr(aAttr);
1640*b1cdbd2cSJim Jagielski else
1641*b1cdbd2cSJim Jagielski {
1642*b1cdbd2cSJim Jagielski //Here we have a tab definition which inserts no extra tabs, or deletes
1643*b1cdbd2cSJim Jagielski //no existing tabs. An older version of writer is probably the creater
1644*b1cdbd2cSJim Jagielski //of the document :-( . So if we are importing a style we can just
1645*b1cdbd2cSJim Jagielski //ignore it. But if we are importing into text we cannot as during
1646*b1cdbd2cSJim Jagielski //text SwWW8ImplReader::Read_Tab is called at the begin and end of
1647*b1cdbd2cSJim Jagielski //the range the attrib affects, and ignoring it would upset the
1648*b1cdbd2cSJim Jagielski //balance
1649*b1cdbd2cSJim Jagielski if (!pAktColl) //not importing into a style
1650*b1cdbd2cSJim Jagielski {
1651*b1cdbd2cSJim Jagielski using namespace sw::util;
1652*b1cdbd2cSJim Jagielski SvxTabStopItem aOrig = pSty ?
1653*b1cdbd2cSJim Jagielski ItemGet<SvxTabStopItem>(*pSty, RES_PARATR_TABSTOP) :
1654*b1cdbd2cSJim Jagielski DefaultItemGet<SvxTabStopItem>(rDoc, RES_PARATR_TABSTOP);
1655*b1cdbd2cSJim Jagielski NewAttr(aOrig);
1656*b1cdbd2cSJim Jagielski }
1657*b1cdbd2cSJim Jagielski }
1658*b1cdbd2cSJim Jagielski }
1659*b1cdbd2cSJim Jagielski
1660*b1cdbd2cSJim Jagielski //-----------------------------------------
1661*b1cdbd2cSJim Jagielski // DOP
1662*b1cdbd2cSJim Jagielski //-----------------------------------------
1663*b1cdbd2cSJim Jagielski
ImportDop()1664*b1cdbd2cSJim Jagielski void SwWW8ImplReader::ImportDop()
1665*b1cdbd2cSJim Jagielski {
1666*b1cdbd2cSJim Jagielski maTracer.EnterEnvironment(sw::log::eDocumentProperties);
1667*b1cdbd2cSJim Jagielski // correct the LastPrinted date in DocumentInfo
1668*b1cdbd2cSJim Jagielski uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
1669*b1cdbd2cSJim Jagielski mpDocShell->GetModel(), uno::UNO_QUERY_THROW);
1670*b1cdbd2cSJim Jagielski uno::Reference<document::XDocumentProperties> xDocuProps(
1671*b1cdbd2cSJim Jagielski xDPS->getDocumentProperties());
1672*b1cdbd2cSJim Jagielski DBG_ASSERT(xDocuProps.is(), "DocumentProperties is null");
1673*b1cdbd2cSJim Jagielski if (xDocuProps.is())
1674*b1cdbd2cSJim Jagielski {
1675*b1cdbd2cSJim Jagielski DateTime aLastPrinted(
1676*b1cdbd2cSJim Jagielski sw::ms::DTTM2DateTime(pWDop->dttmLastPrint));
1677*b1cdbd2cSJim Jagielski ::util::DateTime uDT(aLastPrinted.Get100Sec(),
1678*b1cdbd2cSJim Jagielski aLastPrinted.GetSec(), aLastPrinted.GetMin(),
1679*b1cdbd2cSJim Jagielski aLastPrinted.GetHour(), aLastPrinted.GetDay(),
1680*b1cdbd2cSJim Jagielski aLastPrinted.GetMonth(), aLastPrinted.GetYear());
1681*b1cdbd2cSJim Jagielski xDocuProps->setPrintDate(uDT);
1682*b1cdbd2cSJim Jagielski }
1683*b1cdbd2cSJim Jagielski
1684*b1cdbd2cSJim Jagielski //
1685*b1cdbd2cSJim Jagielski // COMPATIBILITY FLAGS START
1686*b1cdbd2cSJim Jagielski //
1687*b1cdbd2cSJim Jagielski
1688*b1cdbd2cSJim Jagielski // #i78951# - remember the unknown compatability options
1689*b1cdbd2cSJim Jagielski // so as to export them out
1690*b1cdbd2cSJim Jagielski rDoc.Setn32DummyCompatabilityOptions1( pWDop->GetCompatabilityOptions());
1691*b1cdbd2cSJim Jagielski rDoc.Setn32DummyCompatabilityOptions2( pWDop->GetCompatabilityOptions2());
1692*b1cdbd2cSJim Jagielski
1693*b1cdbd2cSJim Jagielski // Abstand zwischen zwei Absaetzen ist die SUMME von unterem
1694*b1cdbd2cSJim Jagielski // Abst. des ersten und oberem Abst. des zweiten
1695*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::PARA_SPACE_MAX, pWDop->fDontUseHTMLAutoSpacing);
1696*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::PARA_SPACE_MAX_AT_PAGES, true );
1697*b1cdbd2cSJim Jagielski maTracer.Log(sw::log::eDontUseHTMLAutoSpacing);
1698*b1cdbd2cSJim Jagielski // move tabs on alignment
1699*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::TAB_COMPAT, true);
1700*b1cdbd2cSJim Jagielski // #i24363# tab stops relative to indent
1701*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::TABS_RELATIVE_TO_INDENT, false);
1702*b1cdbd2cSJim Jagielski maTracer.Log(sw::log::eTabStopDistance);
1703*b1cdbd2cSJim Jagielski // #i18732# - adjust default of option 'FollowTextFlow'
1704*b1cdbd2cSJim Jagielski rDoc.SetDefault( SwFmtFollowTextFlow( sal_False ) );
1705*b1cdbd2cSJim Jagielski
1706*b1cdbd2cSJim Jagielski // Import Default-Tabs
1707*b1cdbd2cSJim Jagielski long nDefTabSiz = pWDop->dxaTab;
1708*b1cdbd2cSJim Jagielski if( nDefTabSiz < 56 )
1709*b1cdbd2cSJim Jagielski nDefTabSiz = 709;
1710*b1cdbd2cSJim Jagielski
1711*b1cdbd2cSJim Jagielski // wir wollen genau einen DefaultTab
1712*b1cdbd2cSJim Jagielski SvxTabStopItem aNewTab( 1, sal_uInt16(nDefTabSiz), SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP );
1713*b1cdbd2cSJim Jagielski ((SvxTabStop&)aNewTab[0]).GetAdjustment() = SVX_TAB_ADJUST_DEFAULT;
1714*b1cdbd2cSJim Jagielski
1715*b1cdbd2cSJim Jagielski rDoc.GetAttrPool().SetPoolDefaultItem( aNewTab );
1716*b1cdbd2cSJim Jagielski
1717*b1cdbd2cSJim Jagielski if (!pWDop->fUsePrinterMetrics)
1718*b1cdbd2cSJim Jagielski maTracer.Log(sw::log::ePrinterMetrics);
1719*b1cdbd2cSJim Jagielski
1720*b1cdbd2cSJim Jagielski if (!pWDop->fNoLeading)
1721*b1cdbd2cSJim Jagielski maTracer.Log(sw::log::eExtraLeading);
1722*b1cdbd2cSJim Jagielski
1723*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::USE_VIRTUAL_DEVICE, !pWDop->fUsePrinterMetrics);
1724*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::USE_HIRES_VIRTUAL_DEVICE, true);
1725*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::ADD_FLY_OFFSETS, true );
1726*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::ADD_EXT_LEADING, !pWDop->fNoLeading);
1727*b1cdbd2cSJim Jagielski
1728*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::OLD_NUMBERING, false);
1729*b1cdbd2cSJim Jagielski
1730*b1cdbd2cSJim Jagielski // #i47448#
1731*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::IGNORE_FIRST_LINE_INDENT_IN_NUMBERING, false);
1732*b1cdbd2cSJim Jagielski
1733*b1cdbd2cSJim Jagielski // #i49277#
1734*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::DO_NOT_JUSTIFY_LINES_WITH_MANUAL_BREAK, !pWDop->fExpShRtn); // #i56856#
1735*b1cdbd2cSJim Jagielski // #i53199#
1736*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::DO_NOT_RESET_PARA_ATTRS_FOR_NUM_FONT, false);
1737*b1cdbd2cSJim Jagielski
1738*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::OLD_LINE_SPACING, false);
1739*b1cdbd2cSJim Jagielski
1740*b1cdbd2cSJim Jagielski // #i25901#- set new compatibility option 'Add paragraph and table spacing at bottom of table cells'
1741*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::ADD_PARA_SPACING_TO_TABLE_CELLS, true);
1742*b1cdbd2cSJim Jagielski
1743*b1cdbd2cSJim Jagielski // #i11860# - set new compatibility option 'Use former object positioning' to <sal_False>
1744*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::USE_FORMER_OBJECT_POS, false);
1745*b1cdbd2cSJim Jagielski
1746*b1cdbd2cSJim Jagielski // #i27767# - set new compatibility option 'Conder Wrapping mode when positioning object' to <sal_True>
1747*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::CONSIDER_WRAP_ON_OBJECT_POSITION, true);
1748*b1cdbd2cSJim Jagielski
1749*b1cdbd2cSJim Jagielski // #i13832#, #i24135#
1750*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::USE_FORMER_TEXT_WRAPPING, false);
1751*b1cdbd2cSJim Jagielski
1752*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::TABLE_ROW_KEEP, true);
1753*b1cdbd2cSJim Jagielski
1754*b1cdbd2cSJim Jagielski // #i3952#
1755*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::IGNORE_TABS_AND_BLANKS_FOR_LINE_CALCULATION, true);
1756*b1cdbd2cSJim Jagielski
1757*b1cdbd2cSJim Jagielski //
1758*b1cdbd2cSJim Jagielski // COMPATIBILITY FLAGS END
1759*b1cdbd2cSJim Jagielski //
1760*b1cdbd2cSJim Jagielski
1761*b1cdbd2cSJim Jagielski if (!pWDop->fNoLeading)
1762*b1cdbd2cSJim Jagielski maTracer.Log(sw::log::eExtraLeading);
1763*b1cdbd2cSJim Jagielski
1764*b1cdbd2cSJim Jagielski //import magic doptypography information, if its there
1765*b1cdbd2cSJim Jagielski if (pWwFib->nFib > 105)
1766*b1cdbd2cSJim Jagielski ImportDopTypography(pWDop->doptypography);
1767*b1cdbd2cSJim Jagielski
1768*b1cdbd2cSJim Jagielski // disable form design mode to be able to use imported controls directly
1769*b1cdbd2cSJim Jagielski // #i31239# always disable form design mode, not only in protected docs
1770*b1cdbd2cSJim Jagielski {
1771*b1cdbd2cSJim Jagielski using namespace com::sun::star;
1772*b1cdbd2cSJim Jagielski
1773*b1cdbd2cSJim Jagielski uno::Reference<lang::XComponent> xModelComp(mpDocShell->GetModel(),
1774*b1cdbd2cSJim Jagielski uno::UNO_QUERY);
1775*b1cdbd2cSJim Jagielski uno::Reference<beans::XPropertySet> xDocProps(xModelComp,
1776*b1cdbd2cSJim Jagielski uno::UNO_QUERY);
1777*b1cdbd2cSJim Jagielski if (xDocProps.is())
1778*b1cdbd2cSJim Jagielski {
1779*b1cdbd2cSJim Jagielski uno::Reference<beans::XPropertySetInfo> xInfo =
1780*b1cdbd2cSJim Jagielski xDocProps->getPropertySetInfo();
1781*b1cdbd2cSJim Jagielski sal_Bool bValue = false;
1782*b1cdbd2cSJim Jagielski if (xInfo.is())
1783*b1cdbd2cSJim Jagielski {
1784*b1cdbd2cSJim Jagielski if (xInfo->hasPropertyByName(C2U("ApplyFormDesignMode")))
1785*b1cdbd2cSJim Jagielski {
1786*b1cdbd2cSJim Jagielski xDocProps->setPropertyValue(C2U("ApplyFormDesignMode"),
1787*b1cdbd2cSJim Jagielski cppu::bool2any(bValue));
1788*b1cdbd2cSJim Jagielski }
1789*b1cdbd2cSJim Jagielski }
1790*b1cdbd2cSJim Jagielski }
1791*b1cdbd2cSJim Jagielski }
1792*b1cdbd2cSJim Jagielski
1793*b1cdbd2cSJim Jagielski mpDocShell->SetModifyPasswordHash(pWDop->lKeyProtDoc);
1794*b1cdbd2cSJim Jagielski
1795*b1cdbd2cSJim Jagielski {
1796*b1cdbd2cSJim Jagielski const SvtFilterOptions* pOpt = SvtFilterOptions::Get();
1797*b1cdbd2cSJim Jagielski const sal_Bool bUseEnhFields=(pOpt && pOpt->IsUseEnhancedFields());
1798*b1cdbd2cSJim Jagielski if (bUseEnhFields)
1799*b1cdbd2cSJim Jagielski {
1800*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::PROTECT_FORM, pWDop->fProtEnabled );
1801*b1cdbd2cSJim Jagielski }
1802*b1cdbd2cSJim Jagielski }
1803*b1cdbd2cSJim Jagielski
1804*b1cdbd2cSJim Jagielski maTracer.LeaveEnvironment(sw::log::eDocumentProperties);
1805*b1cdbd2cSJim Jagielski }
1806*b1cdbd2cSJim Jagielski
ImportDopTypography(const WW8DopTypography & rTypo)1807*b1cdbd2cSJim Jagielski void SwWW8ImplReader::ImportDopTypography(const WW8DopTypography &rTypo)
1808*b1cdbd2cSJim Jagielski {
1809*b1cdbd2cSJim Jagielski using namespace com::sun::star;
1810*b1cdbd2cSJim Jagielski switch (rTypo.iLevelOfKinsoku)
1811*b1cdbd2cSJim Jagielski {
1812*b1cdbd2cSJim Jagielski case 2: //custom
1813*b1cdbd2cSJim Jagielski {
1814*b1cdbd2cSJim Jagielski i18n::ForbiddenCharacters aForbidden(rTypo.rgxchFPunct,
1815*b1cdbd2cSJim Jagielski rTypo.rgxchLPunct);
1816*b1cdbd2cSJim Jagielski rDoc.setForbiddenCharacters(rTypo.GetConvertedLang(),
1817*b1cdbd2cSJim Jagielski aForbidden);
1818*b1cdbd2cSJim Jagielski //Obviously cannot set the standard level 1 for japanese, so
1819*b1cdbd2cSJim Jagielski //bail out now while we can.
1820*b1cdbd2cSJim Jagielski if (rTypo.GetConvertedLang() == LANGUAGE_JAPANESE)
1821*b1cdbd2cSJim Jagielski return;
1822*b1cdbd2cSJim Jagielski }
1823*b1cdbd2cSJim Jagielski break;
1824*b1cdbd2cSJim Jagielski default:
1825*b1cdbd2cSJim Jagielski break;
1826*b1cdbd2cSJim Jagielski }
1827*b1cdbd2cSJim Jagielski
1828*b1cdbd2cSJim Jagielski /*
1829*b1cdbd2cSJim Jagielski This MS hack means that level 2 of japanese is not in operation, so we put
1830*b1cdbd2cSJim Jagielski in what we know are the MS defaults, there is a complementary reverse
1831*b1cdbd2cSJim Jagielski hack in the writer. Its our default as well, but we can set it anyway
1832*b1cdbd2cSJim Jagielski as a flag for later.
1833*b1cdbd2cSJim Jagielski */
1834*b1cdbd2cSJim Jagielski if (!rTypo.reserved2)
1835*b1cdbd2cSJim Jagielski {
1836*b1cdbd2cSJim Jagielski i18n::ForbiddenCharacters aForbidden(rTypo.GetJapanNotBeginLevel1(),
1837*b1cdbd2cSJim Jagielski rTypo.GetJapanNotEndLevel1());
1838*b1cdbd2cSJim Jagielski rDoc.setForbiddenCharacters(LANGUAGE_JAPANESE,aForbidden);
1839*b1cdbd2cSJim Jagielski }
1840*b1cdbd2cSJim Jagielski
1841*b1cdbd2cSJim Jagielski rDoc.set(IDocumentSettingAccess::KERN_ASIAN_PUNCTUATION, rTypo.fKerningPunct);
1842*b1cdbd2cSJim Jagielski rDoc.setCharacterCompressionType(static_cast<SwCharCompressType>(rTypo.iJustification));
1843*b1cdbd2cSJim Jagielski }
1844*b1cdbd2cSJim Jagielski
1845*b1cdbd2cSJim Jagielski //-----------------------------------------
1846*b1cdbd2cSJim Jagielski // Fuss- und Endnoten
1847*b1cdbd2cSJim Jagielski
1848*b1cdbd2cSJim Jagielski //-----------------------------------------
1849*b1cdbd2cSJim Jagielski
WW8ReaderSave(SwWW8ImplReader * pRdr,WW8_CP nStartCp)1850*b1cdbd2cSJim Jagielski WW8ReaderSave::WW8ReaderSave(SwWW8ImplReader* pRdr ,WW8_CP nStartCp) :
1851*b1cdbd2cSJim Jagielski maTmpPos(*pRdr->pPaM->GetPoint()),
1852*b1cdbd2cSJim Jagielski mpOldStck(pRdr->pCtrlStck),
1853*b1cdbd2cSJim Jagielski mpOldAnchorStck(pRdr->pAnchorStck),
1854*b1cdbd2cSJim Jagielski mpOldRedlines(pRdr->mpRedlineStack),
1855*b1cdbd2cSJim Jagielski mpOldPlcxMan(pRdr->pPlcxMan),
1856*b1cdbd2cSJim Jagielski mpWFlyPara(pRdr->pWFlyPara),
1857*b1cdbd2cSJim Jagielski mpSFlyPara(pRdr->pSFlyPara),
1858*b1cdbd2cSJim Jagielski mpPreviousNumPaM(pRdr->pPreviousNumPaM),
1859*b1cdbd2cSJim Jagielski mpPrevNumRule(pRdr->pPrevNumRule),
1860*b1cdbd2cSJim Jagielski mpTableDesc(pRdr->pTableDesc),
1861*b1cdbd2cSJim Jagielski mnInTable(pRdr->nInTable),
1862*b1cdbd2cSJim Jagielski mnAktColl(pRdr->nAktColl),
1863*b1cdbd2cSJim Jagielski mcSymbol(pRdr->cSymbol),
1864*b1cdbd2cSJim Jagielski mbIgnoreText(pRdr->bIgnoreText),
1865*b1cdbd2cSJim Jagielski mbSymbol(pRdr->bSymbol),
1866*b1cdbd2cSJim Jagielski mbHdFtFtnEdn(pRdr->bHdFtFtnEdn),
1867*b1cdbd2cSJim Jagielski mbTxbxFlySection(pRdr->bTxbxFlySection),
1868*b1cdbd2cSJim Jagielski mbAnl(pRdr->bAnl),
1869*b1cdbd2cSJim Jagielski mbInHyperlink(pRdr->bInHyperlink),
1870*b1cdbd2cSJim Jagielski mbPgSecBreak(pRdr->bPgSecBreak),
1871*b1cdbd2cSJim Jagielski mbWasParaEnd(pRdr->bWasParaEnd),
1872*b1cdbd2cSJim Jagielski mbHasBorder(pRdr->bHasBorder),
1873*b1cdbd2cSJim Jagielski mbFirstPara(pRdr->bFirstPara)
1874*b1cdbd2cSJim Jagielski {
1875*b1cdbd2cSJim Jagielski pRdr->bSymbol = false;
1876*b1cdbd2cSJim Jagielski pRdr->bHdFtFtnEdn = true;
1877*b1cdbd2cSJim Jagielski pRdr->bTxbxFlySection = pRdr->bAnl = pRdr->bPgSecBreak = pRdr->bWasParaEnd
1878*b1cdbd2cSJim Jagielski = pRdr->bHasBorder = false;
1879*b1cdbd2cSJim Jagielski pRdr->bFirstPara = true;
1880*b1cdbd2cSJim Jagielski pRdr->nInTable = 0;
1881*b1cdbd2cSJim Jagielski pRdr->pWFlyPara = 0;
1882*b1cdbd2cSJim Jagielski pRdr->pSFlyPara = 0;
1883*b1cdbd2cSJim Jagielski pRdr->pPreviousNumPaM = 0;
1884*b1cdbd2cSJim Jagielski pRdr->pPrevNumRule = 0;
1885*b1cdbd2cSJim Jagielski pRdr->pTableDesc = 0;
1886*b1cdbd2cSJim Jagielski pRdr->nAktColl = 0;
1887*b1cdbd2cSJim Jagielski
1888*b1cdbd2cSJim Jagielski
1889*b1cdbd2cSJim Jagielski pRdr->pCtrlStck = new SwWW8FltControlStack(&pRdr->rDoc, pRdr->nFieldFlags,
1890*b1cdbd2cSJim Jagielski *pRdr);
1891*b1cdbd2cSJim Jagielski
1892*b1cdbd2cSJim Jagielski pRdr->mpRedlineStack = new sw::util::RedlineStack(pRdr->rDoc);
1893*b1cdbd2cSJim Jagielski
1894*b1cdbd2cSJim Jagielski pRdr->pAnchorStck = new SwWW8FltAnchorStack(&pRdr->rDoc, pRdr->nFieldFlags);
1895*b1cdbd2cSJim Jagielski
1896*b1cdbd2cSJim Jagielski // rette die Attributverwaltung: dies ist noetig, da der neu anzulegende
1897*b1cdbd2cSJim Jagielski // PLCFx Manager natuerlich auf die gleichen FKPs zugreift, wie der alte
1898*b1cdbd2cSJim Jagielski // und deren Start-End-Positionen veraendert...
1899*b1cdbd2cSJim Jagielski if (pRdr->pPlcxMan)
1900*b1cdbd2cSJim Jagielski pRdr->pPlcxMan->SaveAllPLCFx(maPLCFxSave);
1901*b1cdbd2cSJim Jagielski
1902*b1cdbd2cSJim Jagielski if (nStartCp != -1)
1903*b1cdbd2cSJim Jagielski {
1904*b1cdbd2cSJim Jagielski pRdr->pPlcxMan = new WW8PLCFMan(pRdr->pSBase,
1905*b1cdbd2cSJim Jagielski mpOldPlcxMan->GetManType(), nStartCp);
1906*b1cdbd2cSJim Jagielski }
1907*b1cdbd2cSJim Jagielski
1908*b1cdbd2cSJim Jagielski maOldApos.push_back(false);
1909*b1cdbd2cSJim Jagielski maOldApos.swap(pRdr->maApos);
1910*b1cdbd2cSJim Jagielski maOldFieldStack.swap(pRdr->maFieldStack);
1911*b1cdbd2cSJim Jagielski }
1912*b1cdbd2cSJim Jagielski
Restore(SwWW8ImplReader * pRdr)1913*b1cdbd2cSJim Jagielski void WW8ReaderSave::Restore( SwWW8ImplReader* pRdr )
1914*b1cdbd2cSJim Jagielski {
1915*b1cdbd2cSJim Jagielski pRdr->pWFlyPara = mpWFlyPara;
1916*b1cdbd2cSJim Jagielski pRdr->pSFlyPara = mpSFlyPara;
1917*b1cdbd2cSJim Jagielski pRdr->pPreviousNumPaM = mpPreviousNumPaM;
1918*b1cdbd2cSJim Jagielski pRdr->pPrevNumRule = mpPrevNumRule;
1919*b1cdbd2cSJim Jagielski pRdr->pTableDesc = mpTableDesc;
1920*b1cdbd2cSJim Jagielski pRdr->cSymbol = mcSymbol;
1921*b1cdbd2cSJim Jagielski pRdr->bSymbol = mbSymbol;
1922*b1cdbd2cSJim Jagielski pRdr->bIgnoreText = mbIgnoreText;
1923*b1cdbd2cSJim Jagielski pRdr->bHdFtFtnEdn = mbHdFtFtnEdn;
1924*b1cdbd2cSJim Jagielski pRdr->bTxbxFlySection = mbTxbxFlySection;
1925*b1cdbd2cSJim Jagielski pRdr->nInTable = mnInTable;
1926*b1cdbd2cSJim Jagielski pRdr->bAnl = mbAnl;
1927*b1cdbd2cSJim Jagielski pRdr->bInHyperlink = mbInHyperlink;
1928*b1cdbd2cSJim Jagielski pRdr->bWasParaEnd = mbWasParaEnd;
1929*b1cdbd2cSJim Jagielski pRdr->bPgSecBreak = mbPgSecBreak;
1930*b1cdbd2cSJim Jagielski pRdr->nAktColl = mnAktColl;
1931*b1cdbd2cSJim Jagielski pRdr->bHasBorder = mbHasBorder;
1932*b1cdbd2cSJim Jagielski pRdr->bFirstPara = mbFirstPara;
1933*b1cdbd2cSJim Jagielski
1934*b1cdbd2cSJim Jagielski // schliesse alle Attribute, da sonst Attribute
1935*b1cdbd2cSJim Jagielski // entstehen koennen, die aus dem Fly rausragen
1936*b1cdbd2cSJim Jagielski pRdr->DeleteCtrlStk();
1937*b1cdbd2cSJim Jagielski pRdr->pCtrlStck = mpOldStck;
1938*b1cdbd2cSJim Jagielski
1939*b1cdbd2cSJim Jagielski pRdr->mpRedlineStack->closeall(*pRdr->pPaM->GetPoint());
1940*b1cdbd2cSJim Jagielski delete pRdr->mpRedlineStack;
1941*b1cdbd2cSJim Jagielski pRdr->mpRedlineStack = mpOldRedlines;
1942*b1cdbd2cSJim Jagielski
1943*b1cdbd2cSJim Jagielski pRdr->DeleteAnchorStk();
1944*b1cdbd2cSJim Jagielski pRdr->pAnchorStck = mpOldAnchorStck;
1945*b1cdbd2cSJim Jagielski
1946*b1cdbd2cSJim Jagielski *pRdr->pPaM->GetPoint() = maTmpPos;
1947*b1cdbd2cSJim Jagielski
1948*b1cdbd2cSJim Jagielski if (mpOldPlcxMan != pRdr->pPlcxMan)
1949*b1cdbd2cSJim Jagielski {
1950*b1cdbd2cSJim Jagielski delete pRdr->pPlcxMan;
1951*b1cdbd2cSJim Jagielski pRdr->pPlcxMan = mpOldPlcxMan;
1952*b1cdbd2cSJim Jagielski }
1953*b1cdbd2cSJim Jagielski if (pRdr->pPlcxMan)
1954*b1cdbd2cSJim Jagielski pRdr->pPlcxMan->RestoreAllPLCFx(maPLCFxSave);
1955*b1cdbd2cSJim Jagielski pRdr->maApos.swap(maOldApos);
1956*b1cdbd2cSJim Jagielski pRdr->maFieldStack.swap(maOldFieldStack);
1957*b1cdbd2cSJim Jagielski }
1958*b1cdbd2cSJim Jagielski
Read_HdFtFtnText(const SwNodeIndex * pSttIdx,long nStartCp,long nLen,ManTypes nType)1959*b1cdbd2cSJim Jagielski void SwWW8ImplReader::Read_HdFtFtnText( const SwNodeIndex* pSttIdx,
1960*b1cdbd2cSJim Jagielski long nStartCp, long nLen, ManTypes nType )
1961*b1cdbd2cSJim Jagielski {
1962*b1cdbd2cSJim Jagielski // rettet Flags u.ae. u. setzt sie zurueck
1963*b1cdbd2cSJim Jagielski WW8ReaderSave aSave( this );
1964*b1cdbd2cSJim Jagielski
1965*b1cdbd2cSJim Jagielski pPaM->GetPoint()->nNode = pSttIdx->GetIndex() + 1; //
1966*b1cdbd2cSJim Jagielski pPaM->GetPoint()->nContent.Assign( pPaM->GetCntntNode(), 0 );
1967*b1cdbd2cSJim Jagielski
1968*b1cdbd2cSJim Jagielski // dann Text fuer Header, Footer o. Footnote einlesen
1969*b1cdbd2cSJim Jagielski
1970*b1cdbd2cSJim Jagielski ReadText( nStartCp, nLen, nType ); // Sepx dabei ignorieren
1971*b1cdbd2cSJim Jagielski aSave.Restore( this );
1972*b1cdbd2cSJim Jagielski }
1973*b1cdbd2cSJim Jagielski
1974*b1cdbd2cSJim Jagielski //Use authornames, if not available fall back to initials.
Read_And(WW8PLCFManResult * pRes)1975*b1cdbd2cSJim Jagielski long SwWW8ImplReader::Read_And(WW8PLCFManResult* pRes)
1976*b1cdbd2cSJim Jagielski {
1977*b1cdbd2cSJim Jagielski WW8PLCFx_SubDoc* pSD = pPlcxMan->GetAtn();
1978*b1cdbd2cSJim Jagielski if( !pSD )
1979*b1cdbd2cSJim Jagielski return 0;
1980*b1cdbd2cSJim Jagielski
1981*b1cdbd2cSJim Jagielski String sAuthor;
1982*b1cdbd2cSJim Jagielski if( bVer67 )
1983*b1cdbd2cSJim Jagielski {
1984*b1cdbd2cSJim Jagielski const WW67_ATRD* pDescri = (const WW67_ATRD*)pSD->GetData();
1985*b1cdbd2cSJim Jagielski const String* pA = GetAnnotationAuthor(SVBT16ToShort(pDescri->ibst));
1986*b1cdbd2cSJim Jagielski if (pA)
1987*b1cdbd2cSJim Jagielski sAuthor = *pA;
1988*b1cdbd2cSJim Jagielski else
1989*b1cdbd2cSJim Jagielski sAuthor = String(pDescri->xstUsrInitl + 1, pDescri->xstUsrInitl[0],
1990*b1cdbd2cSJim Jagielski RTL_TEXTENCODING_MS_1252);
1991*b1cdbd2cSJim Jagielski }
1992*b1cdbd2cSJim Jagielski else
1993*b1cdbd2cSJim Jagielski {
1994*b1cdbd2cSJim Jagielski const WW8_ATRD* pDescri = (const WW8_ATRD*)pSD->GetData();
1995*b1cdbd2cSJim Jagielski
1996*b1cdbd2cSJim Jagielski if (const String* pA = GetAnnotationAuthor(SVBT16ToShort(pDescri->ibst)))
1997*b1cdbd2cSJim Jagielski sAuthor = *pA;
1998*b1cdbd2cSJim Jagielski else
1999*b1cdbd2cSJim Jagielski {
2000*b1cdbd2cSJim Jagielski sal_uInt16 nLen = SVBT16ToShort(pDescri->xstUsrInitl[0]);
2001*b1cdbd2cSJim Jagielski for(sal_uInt16 nIdx = 1; nIdx <= nLen; ++nIdx)
2002*b1cdbd2cSJim Jagielski sAuthor += SVBT16ToShort(pDescri->xstUsrInitl[nIdx]);
2003*b1cdbd2cSJim Jagielski }
2004*b1cdbd2cSJim Jagielski }
2005*b1cdbd2cSJim Jagielski
2006*b1cdbd2cSJim Jagielski sal_uInt32 nDateTime = 0;
2007*b1cdbd2cSJim Jagielski
2008*b1cdbd2cSJim Jagielski if (sal_uInt8 * pExtended = pPlcxMan->GetExtendedAtrds()) // Word < 2002 has no date data for comments
2009*b1cdbd2cSJim Jagielski {
2010*b1cdbd2cSJim Jagielski sal_uLong nIndex = pSD->GetIdx() & 0xFFFF; //Index is (stupidly) multiplexed for WW8PLCFx_SubDocs
2011*b1cdbd2cSJim Jagielski if (pWwFib->lcbAtrdExtra/18 > nIndex)
2012*b1cdbd2cSJim Jagielski nDateTime = SVBT32ToUInt32(*(SVBT32*)(pExtended+(nIndex*18)));
2013*b1cdbd2cSJim Jagielski }
2014*b1cdbd2cSJim Jagielski
2015*b1cdbd2cSJim Jagielski DateTime aDate = sw::ms::DTTM2DateTime(nDateTime);
2016*b1cdbd2cSJim Jagielski
2017*b1cdbd2cSJim Jagielski String sTxt;
2018*b1cdbd2cSJim Jagielski OutlinerParaObject *pOutliner = ImportAsOutliner( sTxt, pRes->nCp2OrIdx,
2019*b1cdbd2cSJim Jagielski pRes->nCp2OrIdx + pRes->nMemLen, MAN_AND );
2020*b1cdbd2cSJim Jagielski
2021*b1cdbd2cSJim Jagielski this->pFmtOfJustInsertedApo = 0;
2022*b1cdbd2cSJim Jagielski SwPostItField aPostIt(
2023*b1cdbd2cSJim Jagielski (SwPostItFieldType*)rDoc.GetSysFldType(RES_POSTITFLD),
2024*b1cdbd2cSJim Jagielski sTxt,
2025*b1cdbd2cSJim Jagielski sAuthor,
2026*b1cdbd2cSJim Jagielski aEmptyStr,
2027*b1cdbd2cSJim Jagielski aEmptyStr,
2028*b1cdbd2cSJim Jagielski aDate );
2029*b1cdbd2cSJim Jagielski aPostIt.SetTextObject(pOutliner);
2030*b1cdbd2cSJim Jagielski
2031*b1cdbd2cSJim Jagielski pCtrlStck->NewAttr(*pPaM->GetPoint(), SvxCharHiddenItem(false, RES_CHRATR_HIDDEN));
2032*b1cdbd2cSJim Jagielski rDoc.InsertPoolItem(*pPaM, SwFmtFld(aPostIt), 0);
2033*b1cdbd2cSJim Jagielski pCtrlStck->SetAttr(*pPaM->GetPoint(), RES_CHRATR_HIDDEN);
2034*b1cdbd2cSJim Jagielski
2035*b1cdbd2cSJim Jagielski return 0;
2036*b1cdbd2cSJim Jagielski }
2037*b1cdbd2cSJim Jagielski
Read_HdFtTextAsHackedFrame(long nStart,long nLen,SwFrmFmt & rHdFtFmt,sal_uInt16 nPageWidth)2038*b1cdbd2cSJim Jagielski void SwWW8ImplReader::Read_HdFtTextAsHackedFrame(long nStart, long nLen,
2039*b1cdbd2cSJim Jagielski SwFrmFmt &rHdFtFmt, sal_uInt16 nPageWidth)
2040*b1cdbd2cSJim Jagielski {
2041*b1cdbd2cSJim Jagielski const SwNodeIndex* pSttIdx = rHdFtFmt.GetCntnt().GetCntntIdx();
2042*b1cdbd2cSJim Jagielski ASSERT(pSttIdx, "impossible");
2043*b1cdbd2cSJim Jagielski if (!pSttIdx)
2044*b1cdbd2cSJim Jagielski return;
2045*b1cdbd2cSJim Jagielski
2046*b1cdbd2cSJim Jagielski SwPosition aTmpPos(*pPaM->GetPoint());
2047*b1cdbd2cSJim Jagielski
2048*b1cdbd2cSJim Jagielski pPaM->GetPoint()->nNode = pSttIdx->GetIndex() + 1;
2049*b1cdbd2cSJim Jagielski pPaM->GetPoint()->nContent.Assign(pPaM->GetCntntNode(), 0);
2050*b1cdbd2cSJim Jagielski
2051*b1cdbd2cSJim Jagielski SwFlyFrmFmt *pFrame = rDoc.MakeFlySection(FLY_AT_PARA, pPaM->GetPoint());
2052*b1cdbd2cSJim Jagielski
2053*b1cdbd2cSJim Jagielski SwFmtAnchor aAnch( pFrame->GetAnchor() );
2054*b1cdbd2cSJim Jagielski aAnch.SetType( FLY_AT_PARA );
2055*b1cdbd2cSJim Jagielski pFrame->SetFmtAttr( aAnch );
2056*b1cdbd2cSJim Jagielski SwFmtFrmSize aSz(ATT_MIN_SIZE, nPageWidth, MINLAY);
2057*b1cdbd2cSJim Jagielski SwFrmSize eFrmSize = ATT_MIN_SIZE;
2058*b1cdbd2cSJim Jagielski if( eFrmSize != aSz.GetWidthSizeType() )
2059*b1cdbd2cSJim Jagielski aSz.SetWidthSizeType( eFrmSize );
2060*b1cdbd2cSJim Jagielski pFrame->SetFmtAttr(aSz);
2061*b1cdbd2cSJim Jagielski pFrame->SetFmtAttr(SwFmtSurround(SURROUND_THROUGHT));
2062*b1cdbd2cSJim Jagielski pFrame->SetFmtAttr(SwFmtHoriOrient(0, text::HoriOrientation::LEFT)); //iFOO
2063*b1cdbd2cSJim Jagielski
2064*b1cdbd2cSJim Jagielski // #i43427# - send frame for header/footer into background.
2065*b1cdbd2cSJim Jagielski pFrame->SetFmtAttr( SvxOpaqueItem( RES_OPAQUE, false ) );
2066*b1cdbd2cSJim Jagielski SdrObject* pFrmObj = CreateContactObject( pFrame );
2067*b1cdbd2cSJim Jagielski ASSERT( pFrmObj,
2068*b1cdbd2cSJim Jagielski "<SwWW8ImplReader::Read_HdFtTextAsHackedFrame(..)> - missing SdrObject instance" );
2069*b1cdbd2cSJim Jagielski if ( pFrmObj )
2070*b1cdbd2cSJim Jagielski {
2071*b1cdbd2cSJim Jagielski pFrmObj->SetOrdNum( 0L );
2072*b1cdbd2cSJim Jagielski }
2073*b1cdbd2cSJim Jagielski MoveInsideFly(pFrame);
2074*b1cdbd2cSJim Jagielski
2075*b1cdbd2cSJim Jagielski const SwNodeIndex* pHackIdx = pFrame->GetCntnt().GetCntntIdx();
2076*b1cdbd2cSJim Jagielski
2077*b1cdbd2cSJim Jagielski Read_HdFtFtnText(pHackIdx, nStart, nLen - 1, MAN_HDFT);
2078*b1cdbd2cSJim Jagielski
2079*b1cdbd2cSJim Jagielski MoveOutsideFly(pFrame, aTmpPos);
2080*b1cdbd2cSJim Jagielski }
2081*b1cdbd2cSJim Jagielski
Read_HdFtText(long nStart,long nLen,SwFrmFmt * pHdFtFmt)2082*b1cdbd2cSJim Jagielski void SwWW8ImplReader::Read_HdFtText(long nStart, long nLen, SwFrmFmt* pHdFtFmt)
2083*b1cdbd2cSJim Jagielski {
2084*b1cdbd2cSJim Jagielski const SwNodeIndex* pSttIdx = pHdFtFmt->GetCntnt().GetCntntIdx();
2085*b1cdbd2cSJim Jagielski if (!pSttIdx)
2086*b1cdbd2cSJim Jagielski return;
2087*b1cdbd2cSJim Jagielski
2088*b1cdbd2cSJim Jagielski SwPosition aTmpPos( *pPaM->GetPoint() ); // merke alte Cursorposition
2089*b1cdbd2cSJim Jagielski
2090*b1cdbd2cSJim Jagielski Read_HdFtFtnText(pSttIdx, nStart, nLen - 1, MAN_HDFT);
2091*b1cdbd2cSJim Jagielski
2092*b1cdbd2cSJim Jagielski *pPaM->GetPoint() = aTmpPos;
2093*b1cdbd2cSJim Jagielski }
2094*b1cdbd2cSJim Jagielski
2095*b1cdbd2cSJim Jagielski
isValid_HdFt_CP(WW8_CP nHeaderCP) const2096*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::isValid_HdFt_CP(WW8_CP nHeaderCP) const
2097*b1cdbd2cSJim Jagielski {
2098*b1cdbd2cSJim Jagielski //each CP of Plcfhdd MUST be less than FibRgLw97.ccpHdd
2099*b1cdbd2cSJim Jagielski return (nHeaderCP < pWwFib->ccpHdr) ? true : false;
2100*b1cdbd2cSJim Jagielski }
2101*b1cdbd2cSJim Jagielski
HasOwnHeaderFooter(sal_uInt8 nWhichItems,sal_uInt8 grpfIhdt,int nSect)2102*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::HasOwnHeaderFooter(sal_uInt8 nWhichItems, sal_uInt8 grpfIhdt,
2103*b1cdbd2cSJim Jagielski int nSect)
2104*b1cdbd2cSJim Jagielski {
2105*b1cdbd2cSJim Jagielski if (pHdFt)
2106*b1cdbd2cSJim Jagielski {
2107*b1cdbd2cSJim Jagielski WW8_CP start;
2108*b1cdbd2cSJim Jagielski long nLen;
2109*b1cdbd2cSJim Jagielski sal_uInt8 nNumber = 5;
2110*b1cdbd2cSJim Jagielski
2111*b1cdbd2cSJim Jagielski for( sal_uInt8 nI = 0x20; nI; nI >>= 1, nNumber-- )
2112*b1cdbd2cSJim Jagielski {
2113*b1cdbd2cSJim Jagielski if (nI & nWhichItems)
2114*b1cdbd2cSJim Jagielski {
2115*b1cdbd2cSJim Jagielski bool bOk = true;
2116*b1cdbd2cSJim Jagielski if( bVer67 )
2117*b1cdbd2cSJim Jagielski bOk = ( pHdFt->GetTextPos(grpfIhdt, nI, start, nLen ) && nLen >= 2 );
2118*b1cdbd2cSJim Jagielski else
2119*b1cdbd2cSJim Jagielski {
2120*b1cdbd2cSJim Jagielski pHdFt->GetTextPosExact( static_cast< short >(nNumber + (nSect+1)*6), start, nLen);
2121*b1cdbd2cSJim Jagielski bOk = ( 2 <= nLen ) && isValid_HdFt_CP(start);
2122*b1cdbd2cSJim Jagielski }
2123*b1cdbd2cSJim Jagielski
2124*b1cdbd2cSJim Jagielski if (bOk)
2125*b1cdbd2cSJim Jagielski return true;
2126*b1cdbd2cSJim Jagielski }
2127*b1cdbd2cSJim Jagielski }
2128*b1cdbd2cSJim Jagielski }
2129*b1cdbd2cSJim Jagielski return false;
2130*b1cdbd2cSJim Jagielski }
2131*b1cdbd2cSJim Jagielski
Read_HdFt(bool bIsTitle,int nSect,const SwPageDesc * pPrev,const wwSection & rSection)2132*b1cdbd2cSJim Jagielski void SwWW8ImplReader::Read_HdFt(bool bIsTitle, int nSect,
2133*b1cdbd2cSJim Jagielski const SwPageDesc *pPrev, const wwSection &rSection)
2134*b1cdbd2cSJim Jagielski {
2135*b1cdbd2cSJim Jagielski sal_uInt8 nWhichItems = 0;
2136*b1cdbd2cSJim Jagielski SwPageDesc *pPD = 0;
2137*b1cdbd2cSJim Jagielski if (!bIsTitle)
2138*b1cdbd2cSJim Jagielski {
2139*b1cdbd2cSJim Jagielski nWhichItems =
2140*b1cdbd2cSJim Jagielski rSection.maSep.grpfIhdt & ~(WW8_HEADER_FIRST | WW8_FOOTER_FIRST);
2141*b1cdbd2cSJim Jagielski pPD = rSection.mpPage;
2142*b1cdbd2cSJim Jagielski }
2143*b1cdbd2cSJim Jagielski else
2144*b1cdbd2cSJim Jagielski {
2145*b1cdbd2cSJim Jagielski // Always read title page header/footer data - it could be used by following sections
2146*b1cdbd2cSJim Jagielski nWhichItems = ( WW8_HEADER_FIRST | WW8_FOOTER_FIRST );
2147*b1cdbd2cSJim Jagielski pPD = rSection.mpTitlePage;
2148*b1cdbd2cSJim Jagielski }
2149*b1cdbd2cSJim Jagielski
2150*b1cdbd2cSJim Jagielski sal_uInt8 grpfIhdt = rSection.maSep.grpfIhdt;
2151*b1cdbd2cSJim Jagielski
2152*b1cdbd2cSJim Jagielski
2153*b1cdbd2cSJim Jagielski if( pHdFt )
2154*b1cdbd2cSJim Jagielski {
2155*b1cdbd2cSJim Jagielski WW8_CP start;
2156*b1cdbd2cSJim Jagielski long nLen;
2157*b1cdbd2cSJim Jagielski sal_uInt8 nNumber = 5;
2158*b1cdbd2cSJim Jagielski
2159*b1cdbd2cSJim Jagielski for( sal_uInt8 nI = 0x20; nI; nI >>= 1, nNumber-- )
2160*b1cdbd2cSJim Jagielski {
2161*b1cdbd2cSJim Jagielski if (nI & nWhichItems)
2162*b1cdbd2cSJim Jagielski {
2163*b1cdbd2cSJim Jagielski bool bOk = true;
2164*b1cdbd2cSJim Jagielski if( bVer67 )
2165*b1cdbd2cSJim Jagielski bOk = ( pHdFt->GetTextPos(grpfIhdt, nI, start, nLen ) && nLen >= 2 );
2166*b1cdbd2cSJim Jagielski else
2167*b1cdbd2cSJim Jagielski {
2168*b1cdbd2cSJim Jagielski pHdFt->GetTextPosExact( static_cast< short >(nNumber + (nSect+1)*6), start, nLen);
2169*b1cdbd2cSJim Jagielski bOk = ( 2 <= nLen ) && isValid_HdFt_CP(start);
2170*b1cdbd2cSJim Jagielski }
2171*b1cdbd2cSJim Jagielski
2172*b1cdbd2cSJim Jagielski bool bUseLeft
2173*b1cdbd2cSJim Jagielski = (nI & ( WW8_HEADER_EVEN | WW8_FOOTER_EVEN )) ? true: false;
2174*b1cdbd2cSJim Jagielski bool bFooter
2175*b1cdbd2cSJim Jagielski = (nI & ( WW8_FOOTER_EVEN | WW8_FOOTER_ODD | WW8_FOOTER_FIRST )) ? true: false;
2176*b1cdbd2cSJim Jagielski
2177*b1cdbd2cSJim Jagielski SwFrmFmt* pFmt = bUseLeft ? &pPD->GetLeft() : &pPD->GetMaster();
2178*b1cdbd2cSJim Jagielski
2179*b1cdbd2cSJim Jagielski SwFrmFmt* pHdFtFmt;
2180*b1cdbd2cSJim Jagielski if (bFooter)
2181*b1cdbd2cSJim Jagielski {
2182*b1cdbd2cSJim Jagielski bIsFooter = true;
2183*b1cdbd2cSJim Jagielski //#i17196# Cannot have left without right
2184*b1cdbd2cSJim Jagielski if (!pPD->GetMaster().GetFooter().GetFooterFmt())
2185*b1cdbd2cSJim Jagielski pPD->GetMaster().SetFmtAttr(SwFmtFooter(true));
2186*b1cdbd2cSJim Jagielski if (bUseLeft)
2187*b1cdbd2cSJim Jagielski pPD->GetLeft().SetFmtAttr(SwFmtFooter(true));
2188*b1cdbd2cSJim Jagielski pHdFtFmt = (SwFrmFmt*)pFmt->GetFooter().GetFooterFmt();
2189*b1cdbd2cSJim Jagielski }
2190*b1cdbd2cSJim Jagielski else
2191*b1cdbd2cSJim Jagielski {
2192*b1cdbd2cSJim Jagielski bIsHeader = true;
2193*b1cdbd2cSJim Jagielski //#i17196# Cannot have left without right
2194*b1cdbd2cSJim Jagielski if (!pPD->GetMaster().GetHeader().GetHeaderFmt())
2195*b1cdbd2cSJim Jagielski pPD->GetMaster().SetFmtAttr(SwFmtHeader(true));
2196*b1cdbd2cSJim Jagielski if (bUseLeft)
2197*b1cdbd2cSJim Jagielski pPD->GetLeft().SetFmtAttr(SwFmtHeader(true));
2198*b1cdbd2cSJim Jagielski pHdFtFmt = (SwFrmFmt*)pFmt->GetHeader().GetHeaderFmt();
2199*b1cdbd2cSJim Jagielski }
2200*b1cdbd2cSJim Jagielski
2201*b1cdbd2cSJim Jagielski if (bOk)
2202*b1cdbd2cSJim Jagielski {
2203*b1cdbd2cSJim Jagielski bool bHackRequired = false;
2204*b1cdbd2cSJim Jagielski if (bIsHeader && rSection.IsFixedHeightHeader())
2205*b1cdbd2cSJim Jagielski bHackRequired = true;
2206*b1cdbd2cSJim Jagielski else if (bIsFooter && rSection.IsFixedHeightFooter())
2207*b1cdbd2cSJim Jagielski bHackRequired = true;
2208*b1cdbd2cSJim Jagielski
2209*b1cdbd2cSJim Jagielski if (bHackRequired)
2210*b1cdbd2cSJim Jagielski {
2211*b1cdbd2cSJim Jagielski Read_HdFtTextAsHackedFrame(start, nLen, *pHdFtFmt,
2212*b1cdbd2cSJim Jagielski static_cast< sal_uInt16 >(rSection.GetTextAreaWidth()) );
2213*b1cdbd2cSJim Jagielski }
2214*b1cdbd2cSJim Jagielski else
2215*b1cdbd2cSJim Jagielski Read_HdFtText(start, nLen, pHdFtFmt);
2216*b1cdbd2cSJim Jagielski }
2217*b1cdbd2cSJim Jagielski else if (!bOk && pPrev)
2218*b1cdbd2cSJim Jagielski CopyPageDescHdFt(pPrev, pPD, nI);
2219*b1cdbd2cSJim Jagielski
2220*b1cdbd2cSJim Jagielski bIsHeader = bIsFooter = false;
2221*b1cdbd2cSJim Jagielski }
2222*b1cdbd2cSJim Jagielski }
2223*b1cdbd2cSJim Jagielski }
2224*b1cdbd2cSJim Jagielski maTracer.LeaveEnvironment(sw::log::eDocumentProperties);
2225*b1cdbd2cSJim Jagielski }
2226*b1cdbd2cSJim Jagielski
SectionIsProtected(const wwSection & rSection) const2227*b1cdbd2cSJim Jagielski bool wwSectionManager::SectionIsProtected(const wwSection &rSection) const
2228*b1cdbd2cSJim Jagielski {
2229*b1cdbd2cSJim Jagielski return (mrReader.pWwFib->fReadOnlyRecommended && !rSection.IsNotProtected());
2230*b1cdbd2cSJim Jagielski }
2231*b1cdbd2cSJim Jagielski
SetHdFt(wwSection & rSection,int nSect,const wwSection * pPrevious)2232*b1cdbd2cSJim Jagielski void wwSectionManager::SetHdFt(wwSection &rSection, int nSect,
2233*b1cdbd2cSJim Jagielski const wwSection *pPrevious)
2234*b1cdbd2cSJim Jagielski {
2235*b1cdbd2cSJim Jagielski // Header / Footer nicht da
2236*b1cdbd2cSJim Jagielski if (!rSection.maSep.grpfIhdt)
2237*b1cdbd2cSJim Jagielski return;
2238*b1cdbd2cSJim Jagielski
2239*b1cdbd2cSJim Jagielski ASSERT(rSection.mpPage, "makes no sense to call with a main page");
2240*b1cdbd2cSJim Jagielski if (rSection.mpPage)
2241*b1cdbd2cSJim Jagielski {
2242*b1cdbd2cSJim Jagielski mrReader.Read_HdFt(false, nSect, pPrevious ? pPrevious->mpPage : 0,
2243*b1cdbd2cSJim Jagielski rSection);
2244*b1cdbd2cSJim Jagielski }
2245*b1cdbd2cSJim Jagielski
2246*b1cdbd2cSJim Jagielski if (rSection.mpTitlePage)
2247*b1cdbd2cSJim Jagielski {
2248*b1cdbd2cSJim Jagielski // 2 Pagedescs noetig: 1.Seite und folgende
2249*b1cdbd2cSJim Jagielski // 1. Seite einlesen
2250*b1cdbd2cSJim Jagielski mrReader.Read_HdFt(true, nSect, pPrevious ? pPrevious->mpTitlePage : 0,
2251*b1cdbd2cSJim Jagielski rSection);
2252*b1cdbd2cSJim Jagielski }
2253*b1cdbd2cSJim Jagielski
2254*b1cdbd2cSJim Jagielski // Kopf / Fuss - Index Updaten
2255*b1cdbd2cSJim Jagielski // Damit der Index auch spaeter noch stimmt
2256*b1cdbd2cSJim Jagielski if (mrReader.pHdFt)
2257*b1cdbd2cSJim Jagielski mrReader.pHdFt->UpdateIndex(rSection.maSep.grpfIhdt);
2258*b1cdbd2cSJim Jagielski
2259*b1cdbd2cSJim Jagielski }
2260*b1cdbd2cSJim Jagielski
2261*b1cdbd2cSJim Jagielski class AttribHere : public std::unary_function<const xub_StrLen*, bool>
2262*b1cdbd2cSJim Jagielski {
2263*b1cdbd2cSJim Jagielski private:
2264*b1cdbd2cSJim Jagielski xub_StrLen nPosition;
2265*b1cdbd2cSJim Jagielski public:
AttribHere(xub_StrLen nPos)2266*b1cdbd2cSJim Jagielski AttribHere(xub_StrLen nPos) : nPosition(nPos) {}
operator ()(const xub_StrLen * pPosition) const2267*b1cdbd2cSJim Jagielski bool operator()(const xub_StrLen *pPosition) const
2268*b1cdbd2cSJim Jagielski {
2269*b1cdbd2cSJim Jagielski return (*pPosition >= nPosition);
2270*b1cdbd2cSJim Jagielski }
2271*b1cdbd2cSJim Jagielski };
2272*b1cdbd2cSJim Jagielski
AppendTxtNode(SwPosition & rPos)2273*b1cdbd2cSJim Jagielski void SwWW8ImplReader::AppendTxtNode(SwPosition& rPos)
2274*b1cdbd2cSJim Jagielski {
2275*b1cdbd2cSJim Jagielski SwTxtNode* pTxt = pPaM->GetNode()->GetTxtNode();
2276*b1cdbd2cSJim Jagielski
2277*b1cdbd2cSJim Jagielski const SwNumRule* pRule = NULL;
2278*b1cdbd2cSJim Jagielski
2279*b1cdbd2cSJim Jagielski if (pTxt != NULL)
2280*b1cdbd2cSJim Jagielski pRule = sw::util::GetNumRuleFromTxtNode(*pTxt);
2281*b1cdbd2cSJim Jagielski
2282*b1cdbd2cSJim Jagielski if (
2283*b1cdbd2cSJim Jagielski pRule && !pWDop->fDontUseHTMLAutoSpacing &&
2284*b1cdbd2cSJim Jagielski (bParaAutoBefore || bParaAutoAfter)
2285*b1cdbd2cSJim Jagielski )
2286*b1cdbd2cSJim Jagielski {
2287*b1cdbd2cSJim Jagielski // If after spacing is set to auto, set the after space to 0
2288*b1cdbd2cSJim Jagielski if (bParaAutoAfter)
2289*b1cdbd2cSJim Jagielski SetLowerSpacing(*pPaM, 0);
2290*b1cdbd2cSJim Jagielski
2291*b1cdbd2cSJim Jagielski // If the previous textnode had numbering and
2292*b1cdbd2cSJim Jagielski // and before spacing is set to auto, set before space to 0
2293*b1cdbd2cSJim Jagielski if(pPrevNumRule && bParaAutoBefore)
2294*b1cdbd2cSJim Jagielski SetUpperSpacing(*pPaM, 0);
2295*b1cdbd2cSJim Jagielski
2296*b1cdbd2cSJim Jagielski // If the previous numbering rule was different we need
2297*b1cdbd2cSJim Jagielski // to insert a space after the previous paragraph
2298*b1cdbd2cSJim Jagielski if((pRule != pPrevNumRule) && pPreviousNumPaM)
2299*b1cdbd2cSJim Jagielski SetLowerSpacing(*pPreviousNumPaM, GetParagraphAutoSpace(pWDop->fDontUseHTMLAutoSpacing));
2300*b1cdbd2cSJim Jagielski
2301*b1cdbd2cSJim Jagielski // cache current paragraph
2302*b1cdbd2cSJim Jagielski if(pPreviousNumPaM)
2303*b1cdbd2cSJim Jagielski delete pPreviousNumPaM, pPreviousNumPaM = 0;
2304*b1cdbd2cSJim Jagielski
2305*b1cdbd2cSJim Jagielski pPreviousNumPaM = new SwPaM(*pPaM);
2306*b1cdbd2cSJim Jagielski pPrevNumRule = pRule;
2307*b1cdbd2cSJim Jagielski }
2308*b1cdbd2cSJim Jagielski else if(!pRule && pPreviousNumPaM)
2309*b1cdbd2cSJim Jagielski {
2310*b1cdbd2cSJim Jagielski // If the previous paragraph has numbering but the current one does not
2311*b1cdbd2cSJim Jagielski // we need to add a space after the previous paragraph
2312*b1cdbd2cSJim Jagielski SetLowerSpacing(*pPreviousNumPaM, GetParagraphAutoSpace(pWDop->fDontUseHTMLAutoSpacing));
2313*b1cdbd2cSJim Jagielski delete pPreviousNumPaM, pPreviousNumPaM = 0;
2314*b1cdbd2cSJim Jagielski pPrevNumRule = 0;
2315*b1cdbd2cSJim Jagielski }
2316*b1cdbd2cSJim Jagielski else
2317*b1cdbd2cSJim Jagielski {
2318*b1cdbd2cSJim Jagielski // clear paragraph cache
2319*b1cdbd2cSJim Jagielski if(pPreviousNumPaM)
2320*b1cdbd2cSJim Jagielski delete pPreviousNumPaM, pPreviousNumPaM = 0;
2321*b1cdbd2cSJim Jagielski pPrevNumRule = pRule;
2322*b1cdbd2cSJim Jagielski }
2323*b1cdbd2cSJim Jagielski
2324*b1cdbd2cSJim Jagielski // If this is the first paragraph in the document and
2325*b1cdbd2cSJim Jagielski // Auto-spacing before paragraph is set,
2326*b1cdbd2cSJim Jagielski // set the upper spacing value to 0
2327*b1cdbd2cSJim Jagielski if(bParaAutoBefore && bFirstPara && !pWDop->fDontUseHTMLAutoSpacing)
2328*b1cdbd2cSJim Jagielski SetUpperSpacing(*pPaM, 0);
2329*b1cdbd2cSJim Jagielski
2330*b1cdbd2cSJim Jagielski bFirstPara = false;
2331*b1cdbd2cSJim Jagielski
2332*b1cdbd2cSJim Jagielski rDoc.AppendTxtNode(rPos);
2333*b1cdbd2cSJim Jagielski
2334*b1cdbd2cSJim Jagielski //We can flush all anchored graphics at the end of a paragraph.
2335*b1cdbd2cSJim Jagielski pAnchorStck->Flush();
2336*b1cdbd2cSJim Jagielski }
2337*b1cdbd2cSJim Jagielski
SetSpacing(SwPaM & rMyPam,int nSpace,bool bIsUpper)2338*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::SetSpacing(SwPaM &rMyPam, int nSpace, bool bIsUpper )
2339*b1cdbd2cSJim Jagielski {
2340*b1cdbd2cSJim Jagielski bool bRet = false;
2341*b1cdbd2cSJim Jagielski const SwPosition* pSpacingPos = rMyPam.GetPoint();
2342*b1cdbd2cSJim Jagielski
2343*b1cdbd2cSJim Jagielski const SvxULSpaceItem* pULSpaceItem = (const SvxULSpaceItem*)pCtrlStck->GetFmtAttr(*pSpacingPos, RES_UL_SPACE);
2344*b1cdbd2cSJim Jagielski
2345*b1cdbd2cSJim Jagielski if(pULSpaceItem != 0)
2346*b1cdbd2cSJim Jagielski {
2347*b1cdbd2cSJim Jagielski SvxULSpaceItem aUL(*pULSpaceItem);
2348*b1cdbd2cSJim Jagielski
2349*b1cdbd2cSJim Jagielski if(bIsUpper)
2350*b1cdbd2cSJim Jagielski aUL.SetUpper( static_cast< sal_uInt16 >(nSpace) );
2351*b1cdbd2cSJim Jagielski else
2352*b1cdbd2cSJim Jagielski aUL.SetLower( static_cast< sal_uInt16 >(nSpace) );
2353*b1cdbd2cSJim Jagielski
2354*b1cdbd2cSJim Jagielski xub_StrLen nEnd = pSpacingPos->nContent.GetIndex();
2355*b1cdbd2cSJim Jagielski rMyPam.GetPoint()->nContent.Assign(rMyPam.GetCntntNode(), 0);
2356*b1cdbd2cSJim Jagielski pCtrlStck->NewAttr(*pSpacingPos, aUL);
2357*b1cdbd2cSJim Jagielski rMyPam.GetPoint()->nContent.Assign(rMyPam.GetCntntNode(), nEnd);
2358*b1cdbd2cSJim Jagielski pCtrlStck->SetAttr(*pSpacingPos, RES_UL_SPACE);
2359*b1cdbd2cSJim Jagielski bRet = true;
2360*b1cdbd2cSJim Jagielski }
2361*b1cdbd2cSJim Jagielski return bRet;
2362*b1cdbd2cSJim Jagielski }
2363*b1cdbd2cSJim Jagielski
SetLowerSpacing(SwPaM & rMyPam,int nSpace)2364*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::SetLowerSpacing(SwPaM &rMyPam, int nSpace)
2365*b1cdbd2cSJim Jagielski {
2366*b1cdbd2cSJim Jagielski return SetSpacing(rMyPam, nSpace, false);
2367*b1cdbd2cSJim Jagielski }
2368*b1cdbd2cSJim Jagielski
SetUpperSpacing(SwPaM & rMyPam,int nSpace)2369*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::SetUpperSpacing(SwPaM &rMyPam, int nSpace)
2370*b1cdbd2cSJim Jagielski {
2371*b1cdbd2cSJim Jagielski return SetSpacing(rMyPam, nSpace, true);
2372*b1cdbd2cSJim Jagielski }
2373*b1cdbd2cSJim Jagielski
TabRowSprm(int nLevel) const2374*b1cdbd2cSJim Jagielski sal_uInt16 SwWW8ImplReader::TabRowSprm(int nLevel) const
2375*b1cdbd2cSJim Jagielski {
2376*b1cdbd2cSJim Jagielski if (bVer67)
2377*b1cdbd2cSJim Jagielski return 25;
2378*b1cdbd2cSJim Jagielski return nLevel ? 0x244C : 0x2417;
2379*b1cdbd2cSJim Jagielski }
2380*b1cdbd2cSJim Jagielski
EndSpecial()2381*b1cdbd2cSJim Jagielski void SwWW8ImplReader::EndSpecial()
2382*b1cdbd2cSJim Jagielski {
2383*b1cdbd2cSJim Jagielski // Frame / Table / Anl
2384*b1cdbd2cSJim Jagielski if (bAnl)
2385*b1cdbd2cSJim Jagielski StopAllAnl(); // -> bAnl = false
2386*b1cdbd2cSJim Jagielski
2387*b1cdbd2cSJim Jagielski while(maApos.size() > 1)
2388*b1cdbd2cSJim Jagielski {
2389*b1cdbd2cSJim Jagielski StopTable();
2390*b1cdbd2cSJim Jagielski maApos.pop_back();
2391*b1cdbd2cSJim Jagielski --nInTable;
2392*b1cdbd2cSJim Jagielski if (maApos[nInTable] == true)
2393*b1cdbd2cSJim Jagielski StopApo();
2394*b1cdbd2cSJim Jagielski }
2395*b1cdbd2cSJim Jagielski
2396*b1cdbd2cSJim Jagielski if (maApos[0] == true)
2397*b1cdbd2cSJim Jagielski StopApo();
2398*b1cdbd2cSJim Jagielski
2399*b1cdbd2cSJim Jagielski ASSERT(!nInTable, "unclosed table!");
2400*b1cdbd2cSJim Jagielski }
2401*b1cdbd2cSJim Jagielski
ProcessSpecial(bool & rbReSync,WW8_CP nStartCp)2402*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::ProcessSpecial(bool &rbReSync, WW8_CP nStartCp)
2403*b1cdbd2cSJim Jagielski {
2404*b1cdbd2cSJim Jagielski // Frame / Table / Anl
2405*b1cdbd2cSJim Jagielski if (bInHyperlink)
2406*b1cdbd2cSJim Jagielski return false;
2407*b1cdbd2cSJim Jagielski
2408*b1cdbd2cSJim Jagielski rbReSync = false;
2409*b1cdbd2cSJim Jagielski
2410*b1cdbd2cSJim Jagielski ASSERT(nInTable >= 0,"nInTable < 0!");
2411*b1cdbd2cSJim Jagielski
2412*b1cdbd2cSJim Jagielski // TabRowEnd
2413*b1cdbd2cSJim Jagielski bool bTableRowEnd = (pPlcxMan->HasParaSprm(bVer67 ? 25 : 0x2417) != 0 );
2414*b1cdbd2cSJim Jagielski
2415*b1cdbd2cSJim Jagielski // es muss leider fuer jeden Absatz zuerst nachgesehen werden,
2416*b1cdbd2cSJim Jagielski // ob sich unter den sprms
2417*b1cdbd2cSJim Jagielski // das sprm 29 (bzw. 0x261B) befindet, das ein APO einleitet.
2418*b1cdbd2cSJim Jagielski // Alle weiteren sprms beziehen sich dann naemlich auf das APO und nicht
2419*b1cdbd2cSJim Jagielski // auf den normalen Text drumrum.
2420*b1cdbd2cSJim Jagielski // Dasselbe gilt fuer eine Tabelle ( sprm 24 (bzw. 0x2416) )
2421*b1cdbd2cSJim Jagielski // und Anls ( sprm 13 ).
2422*b1cdbd2cSJim Jagielski // WW: Tabelle in APO geht ( Beide Anfaende treten gleichzeitig auf )
2423*b1cdbd2cSJim Jagielski // WW: APO in Tabelle geht nicht
2424*b1cdbd2cSJim Jagielski // d.h. Wenn eine Tabelle Inhalt eines Apo ist, dann muss der
2425*b1cdbd2cSJim Jagielski // Apo-Anfang zuerst bearbeitet werden, damit die Tabelle im Apo steht
2426*b1cdbd2cSJim Jagielski // und nicht umgekehrt. Am Ende muss dagegen zuerst das Tabellenende
2427*b1cdbd2cSJim Jagielski // bearbeitet werden, da die Apo erst nach der Tabelle abgeschlossen
2428*b1cdbd2cSJim Jagielski // werden darf ( sonst wird das Apo-Ende nie gefunden ).
2429*b1cdbd2cSJim Jagielski // Dasselbe gilt fuer Fly / Anl, Tab / Anl, Fly / Tab / Anl.
2430*b1cdbd2cSJim Jagielski //
2431*b1cdbd2cSJim Jagielski // Wenn die Tabelle in einem Apo steht, fehlen im TabRowEnd-Bereich
2432*b1cdbd2cSJim Jagielski // die Apo-Angaben. Damit hier die Apo nicht beendet wird, wird
2433*b1cdbd2cSJim Jagielski // ProcessApo dann nicht aufgerufen.
2434*b1cdbd2cSJim Jagielski
2435*b1cdbd2cSJim Jagielski // KHZ: When there is a table inside the Apo the Apo-flags are also
2436*b1cdbd2cSJim Jagielski // missing for the 2nd, 3rd... paragraphs of each cell.
2437*b1cdbd2cSJim Jagielski
2438*b1cdbd2cSJim Jagielski
2439*b1cdbd2cSJim Jagielski // 1st look for in-table flag, for 2000+ there is a subtable flag to
2440*b1cdbd2cSJim Jagielski // be considered, the sprm 6649 gives the level of the table
2441*b1cdbd2cSJim Jagielski sal_uInt8 nCellLevel = 0;
2442*b1cdbd2cSJim Jagielski
2443*b1cdbd2cSJim Jagielski if (bVer67)
2444*b1cdbd2cSJim Jagielski nCellLevel = 0 != pPlcxMan->HasParaSprm(24);
2445*b1cdbd2cSJim Jagielski else
2446*b1cdbd2cSJim Jagielski {
2447*b1cdbd2cSJim Jagielski nCellLevel = 0 != pPlcxMan->HasParaSprm(0x2416);
2448*b1cdbd2cSJim Jagielski if (!nCellLevel)
2449*b1cdbd2cSJim Jagielski nCellLevel = 0 != pPlcxMan->HasParaSprm(0x244B);
2450*b1cdbd2cSJim Jagielski }
2451*b1cdbd2cSJim Jagielski
2452*b1cdbd2cSJim Jagielski WW8_TablePos *pTabPos=0;
2453*b1cdbd2cSJim Jagielski WW8_TablePos aTabPos;
2454*b1cdbd2cSJim Jagielski WW8PLCFx_Cp_FKP* pPap = 0;
2455*b1cdbd2cSJim Jagielski bool bTableHasPositionInfo = false;
2456*b1cdbd2cSJim Jagielski
2457*b1cdbd2cSJim Jagielski if (nCellLevel && !bVer67)
2458*b1cdbd2cSJim Jagielski {
2459*b1cdbd2cSJim Jagielski WW8PLCFxSave1 aSave;
2460*b1cdbd2cSJim Jagielski pPlcxMan->GetPap()->Save( aSave );
2461*b1cdbd2cSJim Jagielski rbReSync = true;
2462*b1cdbd2cSJim Jagielski pPap = pPlcxMan->GetPapPLCF();
2463*b1cdbd2cSJim Jagielski WW8_CP nMyStartCp=nStartCp;
2464*b1cdbd2cSJim Jagielski
2465*b1cdbd2cSJim Jagielski if (const sal_uInt8 *pLevel = pPlcxMan->HasParaSprm(0x6649))
2466*b1cdbd2cSJim Jagielski nCellLevel = *pLevel;
2467*b1cdbd2cSJim Jagielski
2468*b1cdbd2cSJim Jagielski bool bHasRowEnd = SearchRowEnd(pPap, nMyStartCp, nCellLevel-1);
2469*b1cdbd2cSJim Jagielski
2470*b1cdbd2cSJim Jagielski //Bad Table, remain unchanged in level, e.g. #i19667#
2471*b1cdbd2cSJim Jagielski if (!bHasRowEnd)
2472*b1cdbd2cSJim Jagielski nCellLevel = static_cast< sal_uInt8 >(nInTable);
2473*b1cdbd2cSJim Jagielski
2474*b1cdbd2cSJim Jagielski sal_uLong idstart = rDoc.GetNodes().GetEndOfContent().StartOfSectionIndex(); // get the node index
2475*b1cdbd2cSJim Jagielski sal_uLong idcur = 0;
2476*b1cdbd2cSJim Jagielski if ( pPaM && pPaM->GetPoint() )
2477*b1cdbd2cSJim Jagielski idcur = pPaM->GetPoint()->nNode.GetIndex();
2478*b1cdbd2cSJim Jagielski
2479*b1cdbd2cSJim Jagielski // Memory first table postion info
2480*b1cdbd2cSJim Jagielski if ( !pFirstTablePap && idstart + 1 == idcur )
2481*b1cdbd2cSJim Jagielski pFirstTablePap = pPap;
2482*b1cdbd2cSJim Jagielski
2483*b1cdbd2cSJim Jagielski if ( bHasRowEnd && ParseTabPos(&aTabPos,pPap) )
2484*b1cdbd2cSJim Jagielski {
2485*b1cdbd2cSJim Jagielski // If table front don't have some content and it is doc first table, ignore table text wrapping property
2486*b1cdbd2cSJim Jagielski bTableHasPositionInfo = true;
2487*b1cdbd2cSJim Jagielski if ( pFirstTablePap != pPap )
2488*b1cdbd2cSJim Jagielski pTabPos = &aTabPos;
2489*b1cdbd2cSJim Jagielski }
2490*b1cdbd2cSJim Jagielski
2491*b1cdbd2cSJim Jagielski pPlcxMan->GetPap()->Restore( aSave );
2492*b1cdbd2cSJim Jagielski }
2493*b1cdbd2cSJim Jagielski
2494*b1cdbd2cSJim Jagielski // then look if we are in an Apo
2495*b1cdbd2cSJim Jagielski
2496*b1cdbd2cSJim Jagielski ApoTestResults aApo = TestApo(nCellLevel, bTableRowEnd, pTabPos, !(pFirstTablePap == pPap && bTableHasPositionInfo));
2497*b1cdbd2cSJim Jagielski
2498*b1cdbd2cSJim Jagielski //look to see if we are in a Table, but Table in foot/end note not allowed
2499*b1cdbd2cSJim Jagielski bool bStartTab = (nInTable < nCellLevel) && !bFtnEdn;
2500*b1cdbd2cSJim Jagielski
2501*b1cdbd2cSJim Jagielski bool bStopTab = bWasTabRowEnd && (nInTable > nCellLevel) && !bFtnEdn;
2502*b1cdbd2cSJim Jagielski
2503*b1cdbd2cSJim Jagielski bWasTabRowEnd = false; // must be deactivated right here to prevent next
2504*b1cdbd2cSJim Jagielski // WW8TabDesc::TableCellEnd() from making nonsense
2505*b1cdbd2cSJim Jagielski
2506*b1cdbd2cSJim Jagielski if (nInTable && !bTableRowEnd && !bStopTab && (nInTable == nCellLevel && aApo.HasStartStop()))
2507*b1cdbd2cSJim Jagielski bStopTab = bStartTab = true; // Required to stop and start table
2508*b1cdbd2cSJim Jagielski
2509*b1cdbd2cSJim Jagielski // Dann auf Anl (Nummerierung) testen
2510*b1cdbd2cSJim Jagielski // und dann alle Ereignisse in der richtigen Reihenfolge bearbeiten
2511*b1cdbd2cSJim Jagielski
2512*b1cdbd2cSJim Jagielski if( bAnl && !bTableRowEnd )
2513*b1cdbd2cSJim Jagielski {
2514*b1cdbd2cSJim Jagielski const sal_uInt8* pSprm13 = pPlcxMan->HasParaSprm( 13 );
2515*b1cdbd2cSJim Jagielski if( pSprm13 )
2516*b1cdbd2cSJim Jagielski { // Noch Anl ?
2517*b1cdbd2cSJim Jagielski sal_uInt8 nT = static_cast< sal_uInt8 >(GetNumType( *pSprm13 ));
2518*b1cdbd2cSJim Jagielski if( ( nT != WW8_Pause && nT != nWwNumType ) // Anl-Wechsel
2519*b1cdbd2cSJim Jagielski || aApo.HasStartStop() // erzwungenes Anl-Ende
2520*b1cdbd2cSJim Jagielski || bStopTab || bStartTab )
2521*b1cdbd2cSJim Jagielski {
2522*b1cdbd2cSJim Jagielski StopAnlToRestart(nT); // Anl-Restart ( = Wechsel ) ueber sprms
2523*b1cdbd2cSJim Jagielski }
2524*b1cdbd2cSJim Jagielski else
2525*b1cdbd2cSJim Jagielski {
2526*b1cdbd2cSJim Jagielski NextAnlLine( pSprm13 ); // naechste Anl-Zeile
2527*b1cdbd2cSJim Jagielski }
2528*b1cdbd2cSJim Jagielski }
2529*b1cdbd2cSJim Jagielski else
2530*b1cdbd2cSJim Jagielski { // Anl normal zuende
2531*b1cdbd2cSJim Jagielski StopAllAnl(); // Wirkliches Ende
2532*b1cdbd2cSJim Jagielski }
2533*b1cdbd2cSJim Jagielski }
2534*b1cdbd2cSJim Jagielski if (bStopTab)
2535*b1cdbd2cSJim Jagielski {
2536*b1cdbd2cSJim Jagielski StopTable();
2537*b1cdbd2cSJim Jagielski maApos.pop_back();
2538*b1cdbd2cSJim Jagielski --nInTable;
2539*b1cdbd2cSJim Jagielski }
2540*b1cdbd2cSJim Jagielski if (aApo.mbStopApo)
2541*b1cdbd2cSJim Jagielski {
2542*b1cdbd2cSJim Jagielski StopApo();
2543*b1cdbd2cSJim Jagielski maApos[nInTable] = false;
2544*b1cdbd2cSJim Jagielski }
2545*b1cdbd2cSJim Jagielski
2546*b1cdbd2cSJim Jagielski if (aApo.mbStartApo)
2547*b1cdbd2cSJim Jagielski {
2548*b1cdbd2cSJim Jagielski maApos[nInTable] = StartApo(aApo, pTabPos);
2549*b1cdbd2cSJim Jagielski // nach StartApo ist ein ReSync noetig ( eigentlich nur, falls die Apo
2550*b1cdbd2cSJim Jagielski // ueber eine FKP-Grenze geht
2551*b1cdbd2cSJim Jagielski rbReSync = true;
2552*b1cdbd2cSJim Jagielski }
2553*b1cdbd2cSJim Jagielski if (bStartTab)
2554*b1cdbd2cSJim Jagielski {
2555*b1cdbd2cSJim Jagielski WW8PLCFxSave1 aSave;
2556*b1cdbd2cSJim Jagielski pPlcxMan->GetPap()->Save( aSave );
2557*b1cdbd2cSJim Jagielski
2558*b1cdbd2cSJim Jagielski if (bAnl) // Nummerierung ueber Zellengrenzen
2559*b1cdbd2cSJim Jagielski StopAllAnl(); // fuehrt zu Absturz -> keine Anls
2560*b1cdbd2cSJim Jagielski // in Tabellen
2561*b1cdbd2cSJim Jagielski while (nInTable < nCellLevel)
2562*b1cdbd2cSJim Jagielski {
2563*b1cdbd2cSJim Jagielski if (StartTable(nStartCp))
2564*b1cdbd2cSJim Jagielski ++nInTable;
2565*b1cdbd2cSJim Jagielski else
2566*b1cdbd2cSJim Jagielski break;
2567*b1cdbd2cSJim Jagielski
2568*b1cdbd2cSJim Jagielski maApos.push_back(false);
2569*b1cdbd2cSJim Jagielski }
2570*b1cdbd2cSJim Jagielski // nach StartTable ist ein ReSync noetig ( eigentlich nur, falls die
2571*b1cdbd2cSJim Jagielski // Tabelle ueber eine FKP-Grenze geht
2572*b1cdbd2cSJim Jagielski rbReSync = true;
2573*b1cdbd2cSJim Jagielski pPlcxMan->GetPap()->Restore( aSave );
2574*b1cdbd2cSJim Jagielski }
2575*b1cdbd2cSJim Jagielski return bTableRowEnd;
2576*b1cdbd2cSJim Jagielski }
2577*b1cdbd2cSJim Jagielski
GetCurrentCharSet()2578*b1cdbd2cSJim Jagielski CharSet SwWW8ImplReader::GetCurrentCharSet()
2579*b1cdbd2cSJim Jagielski {
2580*b1cdbd2cSJim Jagielski /*
2581*b1cdbd2cSJim Jagielski #i2015
2582*b1cdbd2cSJim Jagielski If the hard charset is set use it, if not see if there is an open
2583*b1cdbd2cSJim Jagielski character run that has set the charset, if not then fallback to the
2584*b1cdbd2cSJim Jagielski current underlying paragraph style.
2585*b1cdbd2cSJim Jagielski */
2586*b1cdbd2cSJim Jagielski CharSet eSrcCharSet = eHardCharSet;
2587*b1cdbd2cSJim Jagielski if (eSrcCharSet == RTL_TEXTENCODING_DONTKNOW)
2588*b1cdbd2cSJim Jagielski {
2589*b1cdbd2cSJim Jagielski if (!maFontSrcCharSets.empty())
2590*b1cdbd2cSJim Jagielski eSrcCharSet = maFontSrcCharSets.top();
2591*b1cdbd2cSJim Jagielski if ((eSrcCharSet == RTL_TEXTENCODING_DONTKNOW) && (nCharFmt != -1))
2592*b1cdbd2cSJim Jagielski eSrcCharSet = pCollA[nCharFmt].GetCharSet();
2593*b1cdbd2cSJim Jagielski if ((eSrcCharSet == RTL_TEXTENCODING_DONTKNOW) && StyleExists(nAktColl))
2594*b1cdbd2cSJim Jagielski eSrcCharSet = pCollA[nAktColl].GetCharSet();
2595*b1cdbd2cSJim Jagielski if (eSrcCharSet == RTL_TEXTENCODING_DONTKNOW)
2596*b1cdbd2cSJim Jagielski { // patch from cmc for #i52786#
2597*b1cdbd2cSJim Jagielski /*
2598*b1cdbd2cSJim Jagielski #i22206#/#i52786#
2599*b1cdbd2cSJim Jagielski The (default) character set used for a run of text is the default
2600*b1cdbd2cSJim Jagielski character set for the version of Word that last saved the document.
2601*b1cdbd2cSJim Jagielski
2602*b1cdbd2cSJim Jagielski This is a bit tentative, more might be required if the concept is correct.
2603*b1cdbd2cSJim Jagielski When later version of word write older 6/95 documents the charset is
2604*b1cdbd2cSJim Jagielski correctly set in the character runs involved, so its hard to reproduce
2605*b1cdbd2cSJim Jagielski documents that require this to be sure of the process involved.
2606*b1cdbd2cSJim Jagielski */
2607*b1cdbd2cSJim Jagielski const SvxLanguageItem *pLang =
2608*b1cdbd2cSJim Jagielski (const SvxLanguageItem*)GetFmtAttr(RES_CHRATR_LANGUAGE);
2609*b1cdbd2cSJim Jagielski if (pLang)
2610*b1cdbd2cSJim Jagielski {
2611*b1cdbd2cSJim Jagielski switch (pLang->GetLanguage())
2612*b1cdbd2cSJim Jagielski {
2613*b1cdbd2cSJim Jagielski case LANGUAGE_CZECH:
2614*b1cdbd2cSJim Jagielski case LANGUAGE_HUNGARIAN:
2615*b1cdbd2cSJim Jagielski case LANGUAGE_POLISH:
2616*b1cdbd2cSJim Jagielski eSrcCharSet = RTL_TEXTENCODING_MS_1250;
2617*b1cdbd2cSJim Jagielski break;
2618*b1cdbd2cSJim Jagielski case LANGUAGE_RUSSIAN:
2619*b1cdbd2cSJim Jagielski eSrcCharSet = RTL_TEXTENCODING_MS_1251;
2620*b1cdbd2cSJim Jagielski break;
2621*b1cdbd2cSJim Jagielski case LANGUAGE_GREEK:
2622*b1cdbd2cSJim Jagielski eSrcCharSet = RTL_TEXTENCODING_MS_1253;
2623*b1cdbd2cSJim Jagielski break;
2624*b1cdbd2cSJim Jagielski case LANGUAGE_TURKISH:
2625*b1cdbd2cSJim Jagielski eSrcCharSet = RTL_TEXTENCODING_MS_1254;
2626*b1cdbd2cSJim Jagielski break;
2627*b1cdbd2cSJim Jagielski default:
2628*b1cdbd2cSJim Jagielski eSrcCharSet = RTL_TEXTENCODING_MS_1252;
2629*b1cdbd2cSJim Jagielski break;
2630*b1cdbd2cSJim Jagielski }
2631*b1cdbd2cSJim Jagielski }
2632*b1cdbd2cSJim Jagielski }
2633*b1cdbd2cSJim Jagielski }
2634*b1cdbd2cSJim Jagielski return eSrcCharSet;
2635*b1cdbd2cSJim Jagielski }
2636*b1cdbd2cSJim Jagielski
2637*b1cdbd2cSJim Jagielski //Takashi Ono for CJK
GetCurrentCJKCharSet()2638*b1cdbd2cSJim Jagielski CharSet SwWW8ImplReader::GetCurrentCJKCharSet()
2639*b1cdbd2cSJim Jagielski {
2640*b1cdbd2cSJim Jagielski /*
2641*b1cdbd2cSJim Jagielski #i2015
2642*b1cdbd2cSJim Jagielski If the hard charset is set use it, if not see if there is an open
2643*b1cdbd2cSJim Jagielski character run that has set the charset, if not then fallback to the
2644*b1cdbd2cSJim Jagielski current underlying paragraph style.
2645*b1cdbd2cSJim Jagielski */
2646*b1cdbd2cSJim Jagielski CharSet eSrcCharSet = eHardCharSet;
2647*b1cdbd2cSJim Jagielski if (eSrcCharSet == RTL_TEXTENCODING_DONTKNOW)
2648*b1cdbd2cSJim Jagielski {
2649*b1cdbd2cSJim Jagielski if (!maFontSrcCJKCharSets.empty())
2650*b1cdbd2cSJim Jagielski eSrcCharSet = maFontSrcCJKCharSets.top();
2651*b1cdbd2cSJim Jagielski if (pCollA != NULL)
2652*b1cdbd2cSJim Jagielski {
2653*b1cdbd2cSJim Jagielski if ((eSrcCharSet == RTL_TEXTENCODING_DONTKNOW) && (nCharFmt != -1))
2654*b1cdbd2cSJim Jagielski eSrcCharSet = pCollA[nCharFmt].GetCJKCharSet();
2655*b1cdbd2cSJim Jagielski if (eSrcCharSet == RTL_TEXTENCODING_DONTKNOW)
2656*b1cdbd2cSJim Jagielski eSrcCharSet = pCollA[nAktColl].GetCJKCharSet();
2657*b1cdbd2cSJim Jagielski }
2658*b1cdbd2cSJim Jagielski if (eSrcCharSet == RTL_TEXTENCODING_DONTKNOW)
2659*b1cdbd2cSJim Jagielski { // patch from cmc for #i52786#
2660*b1cdbd2cSJim Jagielski /*
2661*b1cdbd2cSJim Jagielski #i22206#/#i52786#
2662*b1cdbd2cSJim Jagielski The (default) character set used for a run of text is the default
2663*b1cdbd2cSJim Jagielski character set for the version of Word that last saved the document.
2664*b1cdbd2cSJim Jagielski
2665*b1cdbd2cSJim Jagielski This is a bit tentative, more might be required if the concept is correct.
2666*b1cdbd2cSJim Jagielski When later version of word write older 6/95 documents the charset is
2667*b1cdbd2cSJim Jagielski correctly set in the character runs involved, so its hard to reproduce
2668*b1cdbd2cSJim Jagielski documents that require this to be sure of the process involved.
2669*b1cdbd2cSJim Jagielski */
2670*b1cdbd2cSJim Jagielski const SvxLanguageItem *pLang =
2671*b1cdbd2cSJim Jagielski (const SvxLanguageItem*)GetFmtAttr(RES_CHRATR_LANGUAGE);
2672*b1cdbd2cSJim Jagielski if (pLang)
2673*b1cdbd2cSJim Jagielski {
2674*b1cdbd2cSJim Jagielski switch (pLang->GetLanguage())
2675*b1cdbd2cSJim Jagielski {
2676*b1cdbd2cSJim Jagielski case LANGUAGE_CZECH:
2677*b1cdbd2cSJim Jagielski eSrcCharSet = RTL_TEXTENCODING_MS_1250;
2678*b1cdbd2cSJim Jagielski break;
2679*b1cdbd2cSJim Jagielski default:
2680*b1cdbd2cSJim Jagielski eSrcCharSet = RTL_TEXTENCODING_MS_1252;
2681*b1cdbd2cSJim Jagielski break;
2682*b1cdbd2cSJim Jagielski }
2683*b1cdbd2cSJim Jagielski }
2684*b1cdbd2cSJim Jagielski }
2685*b1cdbd2cSJim Jagielski }
2686*b1cdbd2cSJim Jagielski return eSrcCharSet;
2687*b1cdbd2cSJim Jagielski }
2688*b1cdbd2cSJim Jagielski
PostProcessAttrs()2689*b1cdbd2cSJim Jagielski void SwWW8ImplReader::PostProcessAttrs()
2690*b1cdbd2cSJim Jagielski {
2691*b1cdbd2cSJim Jagielski if (mpPostProcessAttrsInfo != NULL)
2692*b1cdbd2cSJim Jagielski {
2693*b1cdbd2cSJim Jagielski SfxItemIter aIter(mpPostProcessAttrsInfo->mItemSet);
2694*b1cdbd2cSJim Jagielski
2695*b1cdbd2cSJim Jagielski const SfxPoolItem * pItem = aIter.GetCurItem();
2696*b1cdbd2cSJim Jagielski if (pItem != NULL)
2697*b1cdbd2cSJim Jagielski {
2698*b1cdbd2cSJim Jagielski do
2699*b1cdbd2cSJim Jagielski {
2700*b1cdbd2cSJim Jagielski pCtrlStck->NewAttr(*mpPostProcessAttrsInfo->mPaM.GetPoint(),
2701*b1cdbd2cSJim Jagielski *pItem);
2702*b1cdbd2cSJim Jagielski pCtrlStck->SetAttr(*mpPostProcessAttrsInfo->mPaM.GetMark(),
2703*b1cdbd2cSJim Jagielski pItem->Which(), true);
2704*b1cdbd2cSJim Jagielski }
2705*b1cdbd2cSJim Jagielski while (!aIter.IsAtEnd() && 0 != (pItem = aIter.NextItem()));
2706*b1cdbd2cSJim Jagielski }
2707*b1cdbd2cSJim Jagielski
2708*b1cdbd2cSJim Jagielski delete mpPostProcessAttrsInfo;
2709*b1cdbd2cSJim Jagielski mpPostProcessAttrsInfo = NULL;
2710*b1cdbd2cSJim Jagielski }
2711*b1cdbd2cSJim Jagielski }
2712*b1cdbd2cSJim Jagielski
2713*b1cdbd2cSJim Jagielski /*
2714*b1cdbd2cSJim Jagielski #i9241#
2715*b1cdbd2cSJim Jagielski It appears that some documents that are in a baltic 8 bit encoding which has
2716*b1cdbd2cSJim Jagielski some undefined characters can have use made of those characters, in which
2717*b1cdbd2cSJim Jagielski case they default to CP1252. If not then its perhaps that the font encoding
2718*b1cdbd2cSJim Jagielski is only in use for 6/7 and for 8+ if we are in 8bit mode then the encoding
2719*b1cdbd2cSJim Jagielski is always 1252.
2720*b1cdbd2cSJim Jagielski
2721*b1cdbd2cSJim Jagielski So a encoding converter that on an undefined character attempts to
2722*b1cdbd2cSJim Jagielski convert from 1252 on the undefined character
2723*b1cdbd2cSJim Jagielski */
Custom8BitToUnicode(rtl_TextToUnicodeConverter hConverter,sal_Char * pIn,sal_Size nInLen,sal_Unicode * pOut,sal_Size nOutLen)2724*b1cdbd2cSJim Jagielski sal_Size Custom8BitToUnicode(rtl_TextToUnicodeConverter hConverter,
2725*b1cdbd2cSJim Jagielski sal_Char *pIn, sal_Size nInLen, sal_Unicode *pOut, sal_Size nOutLen)
2726*b1cdbd2cSJim Jagielski {
2727*b1cdbd2cSJim Jagielski const sal_uInt32 nFlags =
2728*b1cdbd2cSJim Jagielski RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR |
2729*b1cdbd2cSJim Jagielski RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR |
2730*b1cdbd2cSJim Jagielski RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE |
2731*b1cdbd2cSJim Jagielski RTL_TEXTTOUNICODE_FLAGS_FLUSH;
2732*b1cdbd2cSJim Jagielski
2733*b1cdbd2cSJim Jagielski const sal_uInt32 nFlags2 =
2734*b1cdbd2cSJim Jagielski RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_IGNORE |
2735*b1cdbd2cSJim Jagielski RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_IGNORE |
2736*b1cdbd2cSJim Jagielski RTL_TEXTTOUNICODE_FLAGS_INVALID_IGNORE |
2737*b1cdbd2cSJim Jagielski RTL_TEXTTOUNICODE_FLAGS_FLUSH;
2738*b1cdbd2cSJim Jagielski
2739*b1cdbd2cSJim Jagielski sal_Size nDestChars=0;
2740*b1cdbd2cSJim Jagielski sal_Size nConverted=0;
2741*b1cdbd2cSJim Jagielski
2742*b1cdbd2cSJim Jagielski do
2743*b1cdbd2cSJim Jagielski {
2744*b1cdbd2cSJim Jagielski sal_uInt32 nInfo = 0;
2745*b1cdbd2cSJim Jagielski sal_Size nThisConverted=0;
2746*b1cdbd2cSJim Jagielski
2747*b1cdbd2cSJim Jagielski nDestChars += rtl_convertTextToUnicode(hConverter, 0,
2748*b1cdbd2cSJim Jagielski pIn+nConverted, nInLen-nConverted,
2749*b1cdbd2cSJim Jagielski pOut+nDestChars, nOutLen-nDestChars,
2750*b1cdbd2cSJim Jagielski nFlags, &nInfo, &nThisConverted);
2751*b1cdbd2cSJim Jagielski
2752*b1cdbd2cSJim Jagielski ASSERT(nInfo == 0, "A character conversion failed!");
2753*b1cdbd2cSJim Jagielski
2754*b1cdbd2cSJim Jagielski nConverted += nThisConverted;
2755*b1cdbd2cSJim Jagielski
2756*b1cdbd2cSJim Jagielski if (
2757*b1cdbd2cSJim Jagielski nInfo & RTL_TEXTTOUNICODE_FLAGS_UNDEFINED_ERROR ||
2758*b1cdbd2cSJim Jagielski nInfo & RTL_TEXTTOUNICODE_FLAGS_MBUNDEFINED_ERROR
2759*b1cdbd2cSJim Jagielski )
2760*b1cdbd2cSJim Jagielski {
2761*b1cdbd2cSJim Jagielski sal_Size nOtherConverted;
2762*b1cdbd2cSJim Jagielski rtl_TextToUnicodeConverter hCP1252Converter =
2763*b1cdbd2cSJim Jagielski rtl_createTextToUnicodeConverter(RTL_TEXTENCODING_MS_1252);
2764*b1cdbd2cSJim Jagielski nDestChars += rtl_convertTextToUnicode(hCP1252Converter, 0,
2765*b1cdbd2cSJim Jagielski pIn+nConverted, 1,
2766*b1cdbd2cSJim Jagielski pOut+nDestChars, nOutLen-nDestChars,
2767*b1cdbd2cSJim Jagielski nFlags2, &nInfo, &nOtherConverted);
2768*b1cdbd2cSJim Jagielski rtl_destroyTextToUnicodeConverter(hCP1252Converter);
2769*b1cdbd2cSJim Jagielski nConverted+=1;
2770*b1cdbd2cSJim Jagielski }
2771*b1cdbd2cSJim Jagielski } while (nConverted < nInLen);
2772*b1cdbd2cSJim Jagielski
2773*b1cdbd2cSJim Jagielski return nDestChars;
2774*b1cdbd2cSJim Jagielski }
2775*b1cdbd2cSJim Jagielski
LangUsesHindiNumbers(sal_uInt16 nLang)2776*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::LangUsesHindiNumbers(sal_uInt16 nLang)
2777*b1cdbd2cSJim Jagielski {
2778*b1cdbd2cSJim Jagielski bool bResult = false;
2779*b1cdbd2cSJim Jagielski
2780*b1cdbd2cSJim Jagielski switch (nLang)
2781*b1cdbd2cSJim Jagielski {
2782*b1cdbd2cSJim Jagielski case 0x1401: // Arabic(Algeria)
2783*b1cdbd2cSJim Jagielski case 0x3c01: // Arabic(Bahrain)
2784*b1cdbd2cSJim Jagielski case 0xc01: // Arabic(Egypt)
2785*b1cdbd2cSJim Jagielski case 0x801: // Arabic(Iraq)
2786*b1cdbd2cSJim Jagielski case 0x2c01: // Arabic (Jordan)
2787*b1cdbd2cSJim Jagielski case 0x3401: // Arabic(Kuwait)
2788*b1cdbd2cSJim Jagielski case 0x3001: // Arabic(Lebanon)
2789*b1cdbd2cSJim Jagielski case 0x1001: // Arabic(Libya)
2790*b1cdbd2cSJim Jagielski case 0x1801: // Arabic(Morocco)
2791*b1cdbd2cSJim Jagielski case 0x2001: // Arabic(Oman)
2792*b1cdbd2cSJim Jagielski case 0x4001: // Arabic(Qatar)
2793*b1cdbd2cSJim Jagielski case 0x401: // Arabic(Saudi Arabia)
2794*b1cdbd2cSJim Jagielski case 0x2801: // Arabic(Syria)
2795*b1cdbd2cSJim Jagielski case 0x1c01: // Arabic(Tunisia)
2796*b1cdbd2cSJim Jagielski case 0x3801: // Arabic(U.A.E)
2797*b1cdbd2cSJim Jagielski case 0x2401: // Arabic(Yemen)
2798*b1cdbd2cSJim Jagielski bResult = true;
2799*b1cdbd2cSJim Jagielski break;
2800*b1cdbd2cSJim Jagielski default:
2801*b1cdbd2cSJim Jagielski break;
2802*b1cdbd2cSJim Jagielski }
2803*b1cdbd2cSJim Jagielski
2804*b1cdbd2cSJim Jagielski return bResult;
2805*b1cdbd2cSJim Jagielski }
2806*b1cdbd2cSJim Jagielski
TranslateToHindiNumbers(sal_Unicode nChar)2807*b1cdbd2cSJim Jagielski sal_Unicode SwWW8ImplReader::TranslateToHindiNumbers(sal_Unicode nChar)
2808*b1cdbd2cSJim Jagielski {
2809*b1cdbd2cSJim Jagielski if (nChar >= 0x0030 && nChar <= 0x0039)
2810*b1cdbd2cSJim Jagielski return nChar + 0x0630;
2811*b1cdbd2cSJim Jagielski
2812*b1cdbd2cSJim Jagielski return nChar;
2813*b1cdbd2cSJim Jagielski }
2814*b1cdbd2cSJim Jagielski
2815*b1cdbd2cSJim Jagielski // Returnwert: true for no Sonderzeichen
ReadPlainChars(WW8_CP & rPos,long nEnd,long nCpOfs)2816*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::ReadPlainChars(WW8_CP& rPos, long nEnd, long nCpOfs)
2817*b1cdbd2cSJim Jagielski {
2818*b1cdbd2cSJim Jagielski // Unicode-Flag neu setzen und notfalls File-Pos korrigieren
2819*b1cdbd2cSJim Jagielski // merke: Seek kostet nicht viel, da inline geprueft wird,
2820*b1cdbd2cSJim Jagielski // ob die korrekte FilePos nicht schon erreicht ist.
2821*b1cdbd2cSJim Jagielski WW8_FC nStreamPos = pSBase->WW8Cp2Fc(nCpOfs+rPos, &bIsUnicode);
2822*b1cdbd2cSJim Jagielski pStrm->Seek( nStreamPos );
2823*b1cdbd2cSJim Jagielski
2824*b1cdbd2cSJim Jagielski xub_StrLen nLen;
2825*b1cdbd2cSJim Jagielski if (nEnd - rPos <= (STRING_MAXLEN-1))
2826*b1cdbd2cSJim Jagielski nLen = writer_cast<xub_StrLen>(nEnd - rPos);
2827*b1cdbd2cSJim Jagielski else
2828*b1cdbd2cSJim Jagielski nLen = STRING_MAXLEN-1;
2829*b1cdbd2cSJim Jagielski ASSERT(nLen, "String is 0");
2830*b1cdbd2cSJim Jagielski if (!nLen)
2831*b1cdbd2cSJim Jagielski return true;
2832*b1cdbd2cSJim Jagielski
2833*b1cdbd2cSJim Jagielski const CharSet eSrcCharSet = bVer67 ? GetCurrentCharSet() :
2834*b1cdbd2cSJim Jagielski RTL_TEXTENCODING_MS_1252;
2835*b1cdbd2cSJim Jagielski const CharSet eSrcCJKCharSet = bVer67 ? GetCurrentCJKCharSet() :
2836*b1cdbd2cSJim Jagielski RTL_TEXTENCODING_MS_1252;
2837*b1cdbd2cSJim Jagielski
2838*b1cdbd2cSJim Jagielski // (re)alloc UniString data
2839*b1cdbd2cSJim Jagielski String sPlainCharsBuf;
2840*b1cdbd2cSJim Jagielski
2841*b1cdbd2cSJim Jagielski sal_Unicode* pBuffer = sPlainCharsBuf.AllocBuffer( nLen );
2842*b1cdbd2cSJim Jagielski sal_Unicode* pWork = pBuffer;
2843*b1cdbd2cSJim Jagielski
2844*b1cdbd2cSJim Jagielski sal_Char* p8Bits = NULL;
2845*b1cdbd2cSJim Jagielski
2846*b1cdbd2cSJim Jagielski rtl_TextToUnicodeConverter hConverter = 0;
2847*b1cdbd2cSJim Jagielski if (!bIsUnicode || bVer67)
2848*b1cdbd2cSJim Jagielski hConverter = rtl_createTextToUnicodeConverter(eSrcCharSet);
2849*b1cdbd2cSJim Jagielski
2850*b1cdbd2cSJim Jagielski if (!bIsUnicode)
2851*b1cdbd2cSJim Jagielski p8Bits = new sal_Char[nLen];
2852*b1cdbd2cSJim Jagielski
2853*b1cdbd2cSJim Jagielski // read the stream data
2854*b1cdbd2cSJim Jagielski sal_uInt8 nBCode = 0;
2855*b1cdbd2cSJim Jagielski sal_uInt16 nUCode;
2856*b1cdbd2cSJim Jagielski xub_StrLen nL2;
2857*b1cdbd2cSJim Jagielski
2858*b1cdbd2cSJim Jagielski sal_uInt16 nCTLLang = 0;
2859*b1cdbd2cSJim Jagielski const SfxPoolItem * pItem = GetFmtAttr(RES_CHRATR_CTL_LANGUAGE);
2860*b1cdbd2cSJim Jagielski if (pItem != NULL)
2861*b1cdbd2cSJim Jagielski nCTLLang = dynamic_cast<const SvxLanguageItem *>(pItem)->GetLanguage();
2862*b1cdbd2cSJim Jagielski
2863*b1cdbd2cSJim Jagielski for( nL2 = 0; nL2 < nLen; ++nL2, ++pWork )
2864*b1cdbd2cSJim Jagielski {
2865*b1cdbd2cSJim Jagielski if (bIsUnicode)
2866*b1cdbd2cSJim Jagielski *pStrm >> nUCode; // unicode --> read 2 bytes
2867*b1cdbd2cSJim Jagielski else
2868*b1cdbd2cSJim Jagielski {
2869*b1cdbd2cSJim Jagielski *pStrm >> nBCode; // old code --> read 1 byte
2870*b1cdbd2cSJim Jagielski nUCode = nBCode;
2871*b1cdbd2cSJim Jagielski }
2872*b1cdbd2cSJim Jagielski
2873*b1cdbd2cSJim Jagielski if (pStrm->GetError())
2874*b1cdbd2cSJim Jagielski {
2875*b1cdbd2cSJim Jagielski rPos = WW8_CP_MAX-10; // -> eof or other error
2876*b1cdbd2cSJim Jagielski sPlainCharsBuf.ReleaseBufferAccess( 0 );
2877*b1cdbd2cSJim Jagielski delete [] p8Bits;
2878*b1cdbd2cSJim Jagielski return true;
2879*b1cdbd2cSJim Jagielski }
2880*b1cdbd2cSJim Jagielski
2881*b1cdbd2cSJim Jagielski if ((32 > nUCode) || (0xa0 == nUCode))
2882*b1cdbd2cSJim Jagielski {
2883*b1cdbd2cSJim Jagielski pStrm->SeekRel( bIsUnicode ? -2 : -1 );
2884*b1cdbd2cSJim Jagielski break; // Sonderzeichen < 32, == 0xa0 gefunden
2885*b1cdbd2cSJim Jagielski }
2886*b1cdbd2cSJim Jagielski
2887*b1cdbd2cSJim Jagielski if (bIsUnicode)
2888*b1cdbd2cSJim Jagielski {
2889*b1cdbd2cSJim Jagielski if (!bVer67)
2890*b1cdbd2cSJim Jagielski *pWork = nUCode;
2891*b1cdbd2cSJim Jagielski else
2892*b1cdbd2cSJim Jagielski {
2893*b1cdbd2cSJim Jagielski if (nUCode >= 0x3000) //0x8000 ?
2894*b1cdbd2cSJim Jagielski {
2895*b1cdbd2cSJim Jagielski sal_Char aTest[2];
2896*b1cdbd2cSJim Jagielski aTest[0] = static_cast< sal_Char >((nUCode & 0xFF00) >> 8);
2897*b1cdbd2cSJim Jagielski aTest[1] = static_cast< sal_Char >(nUCode & 0x00FF);
2898*b1cdbd2cSJim Jagielski String aTemp(aTest, 2, eSrcCJKCharSet);
2899*b1cdbd2cSJim Jagielski ASSERT(aTemp.Len() == 1, "so much for that theory");
2900*b1cdbd2cSJim Jagielski *pWork = aTemp.GetChar(0);
2901*b1cdbd2cSJim Jagielski }
2902*b1cdbd2cSJim Jagielski else
2903*b1cdbd2cSJim Jagielski {
2904*b1cdbd2cSJim Jagielski sal_Char cTest = static_cast< sal_Char >(nUCode & 0x00FF);
2905*b1cdbd2cSJim Jagielski Custom8BitToUnicode(hConverter, &cTest, 1, pWork, 1);
2906*b1cdbd2cSJim Jagielski }
2907*b1cdbd2cSJim Jagielski }
2908*b1cdbd2cSJim Jagielski }
2909*b1cdbd2cSJim Jagielski else
2910*b1cdbd2cSJim Jagielski p8Bits[nL2] = nBCode;
2911*b1cdbd2cSJim Jagielski }
2912*b1cdbd2cSJim Jagielski
2913*b1cdbd2cSJim Jagielski if (nL2)
2914*b1cdbd2cSJim Jagielski {
2915*b1cdbd2cSJim Jagielski xub_StrLen nEndUsed = nL2;
2916*b1cdbd2cSJim Jagielski
2917*b1cdbd2cSJim Jagielski if (!bIsUnicode)
2918*b1cdbd2cSJim Jagielski nEndUsed = Custom8BitToUnicode(hConverter, p8Bits, nL2, pBuffer, nLen);
2919*b1cdbd2cSJim Jagielski
2920*b1cdbd2cSJim Jagielski for( xub_StrLen nI = 0; nI < nLen; ++nI, ++pBuffer )
2921*b1cdbd2cSJim Jagielski if (m_bRegardHindiDigits && bBidi && LangUsesHindiNumbers(nCTLLang))
2922*b1cdbd2cSJim Jagielski *pBuffer = TranslateToHindiNumbers(*pBuffer);
2923*b1cdbd2cSJim Jagielski
2924*b1cdbd2cSJim Jagielski sPlainCharsBuf.ReleaseBufferAccess( nEndUsed );
2925*b1cdbd2cSJim Jagielski
2926*b1cdbd2cSJim Jagielski AddTextToParagraph(sPlainCharsBuf);
2927*b1cdbd2cSJim Jagielski rPos += nL2;
2928*b1cdbd2cSJim Jagielski if (!maApos.back()) //a para end in apo doesn't count
2929*b1cdbd2cSJim Jagielski bWasParaEnd = false; //kein CR
2930*b1cdbd2cSJim Jagielski }
2931*b1cdbd2cSJim Jagielski
2932*b1cdbd2cSJim Jagielski if (hConverter)
2933*b1cdbd2cSJim Jagielski rtl_destroyTextToUnicodeConverter(hConverter);
2934*b1cdbd2cSJim Jagielski delete [] p8Bits;
2935*b1cdbd2cSJim Jagielski return nL2 >= nLen;
2936*b1cdbd2cSJim Jagielski }
2937*b1cdbd2cSJim Jagielski
AddTextToParagraph(const String & rAddString)2938*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::AddTextToParagraph(const String& rAddString)
2939*b1cdbd2cSJim Jagielski {
2940*b1cdbd2cSJim Jagielski const SwTxtNode* pNd = pPaM->GetCntntNode()->GetTxtNode();
2941*b1cdbd2cSJim Jagielski if (rAddString.Len())
2942*b1cdbd2cSJim Jagielski {
2943*b1cdbd2cSJim Jagielski /*
2944*b1cdbd2cSJim Jagielski #ifdef DEBUG
2945*b1cdbd2cSJim Jagielski //!! does not compile with debug=t -> unresolved external (dbg_out),
2946*b1cdbd2cSJim Jagielski //!! sommeone who knows what he wants to get should fix this
2947*b1cdbd2cSJim Jagielski // ::std::clog << "<addTextToParagraph>" << dbg_out(rAddString)
2948*b1cdbd2cSJim Jagielski // << "</addTextToParagraph>" << ::std::endl;
2949*b1cdbd2cSJim Jagielski #endif
2950*b1cdbd2cSJim Jagielski */
2951*b1cdbd2cSJim Jagielski if ((pNd->GetTxt().Len() + rAddString.Len()) < STRING_MAXLEN -1)
2952*b1cdbd2cSJim Jagielski {
2953*b1cdbd2cSJim Jagielski rDoc.InsertString(*pPaM, rAddString);
2954*b1cdbd2cSJim Jagielski }
2955*b1cdbd2cSJim Jagielski else
2956*b1cdbd2cSJim Jagielski {
2957*b1cdbd2cSJim Jagielski
2958*b1cdbd2cSJim Jagielski if (pNd->GetTxt().Len()< STRING_MAXLEN -1)
2959*b1cdbd2cSJim Jagielski {
2960*b1cdbd2cSJim Jagielski String sTempStr (rAddString,0,
2961*b1cdbd2cSJim Jagielski STRING_MAXLEN - pNd->GetTxt().Len() -1);
2962*b1cdbd2cSJim Jagielski rDoc.InsertString(*pPaM, sTempStr);
2963*b1cdbd2cSJim Jagielski sTempStr = rAddString.Copy(sTempStr.Len(),
2964*b1cdbd2cSJim Jagielski rAddString.Len() - sTempStr.Len());
2965*b1cdbd2cSJim Jagielski AppendTxtNode(*pPaM->GetPoint());
2966*b1cdbd2cSJim Jagielski rDoc.InsertString(*pPaM, sTempStr);
2967*b1cdbd2cSJim Jagielski }
2968*b1cdbd2cSJim Jagielski else
2969*b1cdbd2cSJim Jagielski {
2970*b1cdbd2cSJim Jagielski AppendTxtNode(*pPaM->GetPoint());
2971*b1cdbd2cSJim Jagielski rDoc.InsertString(*pPaM, rAddString);
2972*b1cdbd2cSJim Jagielski }
2973*b1cdbd2cSJim Jagielski }
2974*b1cdbd2cSJim Jagielski
2975*b1cdbd2cSJim Jagielski bReadTable = false;
2976*b1cdbd2cSJim Jagielski }
2977*b1cdbd2cSJim Jagielski
2978*b1cdbd2cSJim Jagielski return true;
2979*b1cdbd2cSJim Jagielski }
2980*b1cdbd2cSJim Jagielski
2981*b1cdbd2cSJim Jagielski // Returnwert: true for para end
ReadChars(WW8_CP & rPos,WW8_CP nNextAttr,long nTextEnd,long nCpOfs)2982*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::ReadChars(WW8_CP& rPos, WW8_CP nNextAttr, long nTextEnd,
2983*b1cdbd2cSJim Jagielski long nCpOfs)
2984*b1cdbd2cSJim Jagielski {
2985*b1cdbd2cSJim Jagielski long nEnd = ( nNextAttr < nTextEnd ) ? nNextAttr : nTextEnd;
2986*b1cdbd2cSJim Jagielski
2987*b1cdbd2cSJim Jagielski if (bSymbol || bIgnoreText)
2988*b1cdbd2cSJim Jagielski {
2989*b1cdbd2cSJim Jagielski if( bSymbol ) // Spezialzeichen einfuegen
2990*b1cdbd2cSJim Jagielski {
2991*b1cdbd2cSJim Jagielski for(sal_uInt16 nCh = 0; nCh < nEnd - rPos; ++nCh)
2992*b1cdbd2cSJim Jagielski {
2993*b1cdbd2cSJim Jagielski rDoc.InsertString( *pPaM, cSymbol );
2994*b1cdbd2cSJim Jagielski }
2995*b1cdbd2cSJim Jagielski pCtrlStck->SetAttr( *pPaM->GetPoint(), RES_CHRATR_FONT );
2996*b1cdbd2cSJim Jagielski }
2997*b1cdbd2cSJim Jagielski pStrm->SeekRel( nEnd- rPos );
2998*b1cdbd2cSJim Jagielski rPos = nEnd; // ignoriere bis Attributende
2999*b1cdbd2cSJim Jagielski return false;
3000*b1cdbd2cSJim Jagielski }
3001*b1cdbd2cSJim Jagielski
3002*b1cdbd2cSJim Jagielski while (true)
3003*b1cdbd2cSJim Jagielski {
3004*b1cdbd2cSJim Jagielski if (ReadPlainChars(rPos, nEnd, nCpOfs))
3005*b1cdbd2cSJim Jagielski return false; // Fertig
3006*b1cdbd2cSJim Jagielski
3007*b1cdbd2cSJim Jagielski bool bStartLine = ReadChar(rPos, nCpOfs);
3008*b1cdbd2cSJim Jagielski rPos++;
3009*b1cdbd2cSJim Jagielski if (bPgSecBreak || bStartLine || rPos == nEnd) // CR oder Fertig
3010*b1cdbd2cSJim Jagielski {
3011*b1cdbd2cSJim Jagielski return bStartLine;
3012*b1cdbd2cSJim Jagielski }
3013*b1cdbd2cSJim Jagielski }
3014*b1cdbd2cSJim Jagielski }
3015*b1cdbd2cSJim Jagielski
HandlePageBreakChar()3016*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::HandlePageBreakChar()
3017*b1cdbd2cSJim Jagielski {
3018*b1cdbd2cSJim Jagielski bool bParaEndAdded = false;
3019*b1cdbd2cSJim Jagielski //#i1909# section/page breaks should not occur in tables, word
3020*b1cdbd2cSJim Jagielski //itself ignores them in this case.
3021*b1cdbd2cSJim Jagielski if (!nInTable)
3022*b1cdbd2cSJim Jagielski {
3023*b1cdbd2cSJim Jagielski //xushanchuan add for issue106569
3024*b1cdbd2cSJim Jagielski sal_Bool IsTemp=sal_True;
3025*b1cdbd2cSJim Jagielski SwTxtNode* pTemp = pPaM->GetNode()->GetTxtNode();
3026*b1cdbd2cSJim Jagielski if ( pTemp && !( pTemp->GetTxt().Len() ) && ( bFirstPara || bFirstParaOfPage ) )
3027*b1cdbd2cSJim Jagielski {
3028*b1cdbd2cSJim Jagielski IsTemp = sal_False;
3029*b1cdbd2cSJim Jagielski AppendTxtNode(*pPaM->GetPoint());
3030*b1cdbd2cSJim Jagielski pTemp->SetAttr(*GetDfltAttr(RES_PARATR_NUMRULE));
3031*b1cdbd2cSJim Jagielski }
3032*b1cdbd2cSJim Jagielski //xushanchuan end
3033*b1cdbd2cSJim Jagielski bPgSecBreak = true;
3034*b1cdbd2cSJim Jagielski pCtrlStck->KillUnlockedAttrs(*pPaM->GetPoint());
3035*b1cdbd2cSJim Jagielski /*
3036*b1cdbd2cSJim Jagielski If its a 0x0c without a paragraph end before it, act like a
3037*b1cdbd2cSJim Jagielski paragraph end, but nevertheless, numbering (and perhaps other
3038*b1cdbd2cSJim Jagielski similiar constructs) do not exist on the para.
3039*b1cdbd2cSJim Jagielski */
3040*b1cdbd2cSJim Jagielski //xushanchuan add for issue106569
3041*b1cdbd2cSJim Jagielski if (!bWasParaEnd && IsTemp)
3042*b1cdbd2cSJim Jagielski //xushanchuan end
3043*b1cdbd2cSJim Jagielski {
3044*b1cdbd2cSJim Jagielski bParaEndAdded = true;
3045*b1cdbd2cSJim Jagielski if (0 >= pPaM->GetPoint()->nContent.GetIndex())
3046*b1cdbd2cSJim Jagielski {
3047*b1cdbd2cSJim Jagielski if (SwTxtNode* pTxtNode = pPaM->GetNode()->GetTxtNode())
3048*b1cdbd2cSJim Jagielski {
3049*b1cdbd2cSJim Jagielski pTxtNode->SetAttr(
3050*b1cdbd2cSJim Jagielski *GetDfltAttr(RES_PARATR_NUMRULE));
3051*b1cdbd2cSJim Jagielski }
3052*b1cdbd2cSJim Jagielski }
3053*b1cdbd2cSJim Jagielski }
3054*b1cdbd2cSJim Jagielski }
3055*b1cdbd2cSJim Jagielski return bParaEndAdded;
3056*b1cdbd2cSJim Jagielski }
3057*b1cdbd2cSJim Jagielski
ReadChar(long nPosCp,long nCpOfs)3058*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::ReadChar(long nPosCp, long nCpOfs)
3059*b1cdbd2cSJim Jagielski {
3060*b1cdbd2cSJim Jagielski bool bNewParaEnd = false;
3061*b1cdbd2cSJim Jagielski // Unicode-Flag neu setzen und notfalls File-Pos korrigieren
3062*b1cdbd2cSJim Jagielski // merke: Seek kostet nicht viel, da inline geprueft wird,
3063*b1cdbd2cSJim Jagielski // ob die korrekte FilePos nicht schon erreicht ist.
3064*b1cdbd2cSJim Jagielski pStrm->Seek( pSBase->WW8Cp2Fc(nCpOfs+nPosCp, &bIsUnicode) );
3065*b1cdbd2cSJim Jagielski
3066*b1cdbd2cSJim Jagielski sal_uInt8 nBCode;
3067*b1cdbd2cSJim Jagielski sal_uInt16 nWCharVal;
3068*b1cdbd2cSJim Jagielski if( bIsUnicode )
3069*b1cdbd2cSJim Jagielski *pStrm >> nWCharVal; // unicode --> read 2 bytes
3070*b1cdbd2cSJim Jagielski else
3071*b1cdbd2cSJim Jagielski {
3072*b1cdbd2cSJim Jagielski *pStrm >> nBCode; // old code --> read 1 byte
3073*b1cdbd2cSJim Jagielski nWCharVal = nBCode;
3074*b1cdbd2cSJim Jagielski }
3075*b1cdbd2cSJim Jagielski
3076*b1cdbd2cSJim Jagielski sal_Char cInsert = '\x0';
3077*b1cdbd2cSJim Jagielski bool bRet = false;
3078*b1cdbd2cSJim Jagielski //xushanchuan add for issue106569
3079*b1cdbd2cSJim Jagielski if ( 0xc != nWCharVal )
3080*b1cdbd2cSJim Jagielski bFirstParaOfPage = false;
3081*b1cdbd2cSJim Jagielski //xushanchuan end
3082*b1cdbd2cSJim Jagielski switch (nWCharVal)
3083*b1cdbd2cSJim Jagielski {
3084*b1cdbd2cSJim Jagielski case 0:
3085*b1cdbd2cSJim Jagielski {
3086*b1cdbd2cSJim Jagielski // Seitennummer
3087*b1cdbd2cSJim Jagielski SwPageNumberField aFld(
3088*b1cdbd2cSJim Jagielski (SwPageNumberFieldType*)rDoc.GetSysFldType(
3089*b1cdbd2cSJim Jagielski RES_PAGENUMBERFLD ), PG_RANDOM, SVX_NUM_ARABIC);
3090*b1cdbd2cSJim Jagielski rDoc.InsertPoolItem(*pPaM, SwFmtFld(aFld), 0);
3091*b1cdbd2cSJim Jagielski }
3092*b1cdbd2cSJim Jagielski break;
3093*b1cdbd2cSJim Jagielski case 0xe:
3094*b1cdbd2cSJim Jagielski // if there is only one column word treats a column break like a pagebreak.
3095*b1cdbd2cSJim Jagielski if (maSectionManager.CurrentSectionColCount() < 2)
3096*b1cdbd2cSJim Jagielski bRet = HandlePageBreakChar();
3097*b1cdbd2cSJim Jagielski else if (!nInTable)
3098*b1cdbd2cSJim Jagielski {
3099*b1cdbd2cSJim Jagielski // Always insert a txtnode for a column break, e.g. ##
3100*b1cdbd2cSJim Jagielski AppendTxtNode(*pPaM->GetPoint());
3101*b1cdbd2cSJim Jagielski rDoc.InsertPoolItem(*pPaM,
3102*b1cdbd2cSJim Jagielski SvxFmtBreakItem(SVX_BREAK_COLUMN_BEFORE, RES_BREAK), 0);
3103*b1cdbd2cSJim Jagielski }
3104*b1cdbd2cSJim Jagielski break;
3105*b1cdbd2cSJim Jagielski case 0x7:
3106*b1cdbd2cSJim Jagielski bNewParaEnd = true;
3107*b1cdbd2cSJim Jagielski TabCellEnd(); // table cell end (Flags abfragen!)
3108*b1cdbd2cSJim Jagielski break;
3109*b1cdbd2cSJim Jagielski case 0xf:
3110*b1cdbd2cSJim Jagielski if( !bSpec ) // "Satellit"
3111*b1cdbd2cSJim Jagielski cInsert = '\xa4';
3112*b1cdbd2cSJim Jagielski break;
3113*b1cdbd2cSJim Jagielski case 0x14:
3114*b1cdbd2cSJim Jagielski if( !bSpec ) // "Para-Ende"-Zeichen
3115*b1cdbd2cSJim Jagielski cInsert = '\xb5';
3116*b1cdbd2cSJim Jagielski break;
3117*b1cdbd2cSJim Jagielski case 0x15:
3118*b1cdbd2cSJim Jagielski if( !bSpec ) // Juristenparagraph
3119*b1cdbd2cSJim Jagielski {
3120*b1cdbd2cSJim Jagielski cp_set::iterator aItr = maTOXEndCps.find((WW8_CP)nPosCp);
3121*b1cdbd2cSJim Jagielski if (aItr == maTOXEndCps.end())
3122*b1cdbd2cSJim Jagielski cInsert = '\xa7';
3123*b1cdbd2cSJim Jagielski else
3124*b1cdbd2cSJim Jagielski maTOXEndCps.erase(aItr);
3125*b1cdbd2cSJim Jagielski }
3126*b1cdbd2cSJim Jagielski break;
3127*b1cdbd2cSJim Jagielski case 0x9:
3128*b1cdbd2cSJim Jagielski cInsert = '\x9'; // Tab
3129*b1cdbd2cSJim Jagielski break;
3130*b1cdbd2cSJim Jagielski case 0xb:
3131*b1cdbd2cSJim Jagielski cInsert = '\xa'; // Hard NewLine
3132*b1cdbd2cSJim Jagielski break;
3133*b1cdbd2cSJim Jagielski case 0xc:
3134*b1cdbd2cSJim Jagielski bRet = HandlePageBreakChar();
3135*b1cdbd2cSJim Jagielski break;
3136*b1cdbd2cSJim Jagielski case 0x1e: // Non-breaking hyphen
3137*b1cdbd2cSJim Jagielski rDoc.InsertString( *pPaM, CHAR_HARDHYPHEN );
3138*b1cdbd2cSJim Jagielski break;
3139*b1cdbd2cSJim Jagielski case 0x1f: // Non-required hyphens
3140*b1cdbd2cSJim Jagielski rDoc.InsertString( *pPaM, CHAR_SOFTHYPHEN );
3141*b1cdbd2cSJim Jagielski break;
3142*b1cdbd2cSJim Jagielski case 0xa0: // Non-breaking spaces
3143*b1cdbd2cSJim Jagielski rDoc.InsertString( *pPaM, CHAR_HARDBLANK );
3144*b1cdbd2cSJim Jagielski break;
3145*b1cdbd2cSJim Jagielski case 0x1:
3146*b1cdbd2cSJim Jagielski /*
3147*b1cdbd2cSJim Jagielski Current thinking is that if bObj is set then we have a
3148*b1cdbd2cSJim Jagielski straightforward "traditional" ole object, otherwise we have a
3149*b1cdbd2cSJim Jagielski graphic preview of an associated ole2 object (or a simple
3150*b1cdbd2cSJim Jagielski graphic of course)
3151*b1cdbd2cSJim Jagielski */
3152*b1cdbd2cSJim Jagielski //normally in the canvas field, the code is 0x8 0x1.
3153*b1cdbd2cSJim Jagielski //in a special case, the code is 0x1 0x1, which yields a simple picture
3154*b1cdbd2cSJim Jagielski {
3155*b1cdbd2cSJim Jagielski bool bReadObj = IsInlineEscherHack();
3156*b1cdbd2cSJim Jagielski if( bReadObj )
3157*b1cdbd2cSJim Jagielski {
3158*b1cdbd2cSJim Jagielski long nCurPos = pStrm->Tell();
3159*b1cdbd2cSJim Jagielski sal_uInt8 nByteCode;
3160*b1cdbd2cSJim Jagielski sal_uInt16 nWordCode;
3161*b1cdbd2cSJim Jagielski
3162*b1cdbd2cSJim Jagielski if( bIsUnicode )
3163*b1cdbd2cSJim Jagielski *pStrm >> nWordCode;
3164*b1cdbd2cSJim Jagielski else
3165*b1cdbd2cSJim Jagielski {
3166*b1cdbd2cSJim Jagielski *pStrm >> nByteCode;
3167*b1cdbd2cSJim Jagielski nWordCode = nByteCode;
3168*b1cdbd2cSJim Jagielski }
3169*b1cdbd2cSJim Jagielski if( nWordCode == 0x1 )
3170*b1cdbd2cSJim Jagielski bReadObj = false;
3171*b1cdbd2cSJim Jagielski pStrm->Seek( nCurPos );
3172*b1cdbd2cSJim Jagielski }
3173*b1cdbd2cSJim Jagielski if( !bReadObj )
3174*b1cdbd2cSJim Jagielski {
3175*b1cdbd2cSJim Jagielski SwFrmFmt *pResult = 0;
3176*b1cdbd2cSJim Jagielski if (bObj)
3177*b1cdbd2cSJim Jagielski pResult = ImportOle();
3178*b1cdbd2cSJim Jagielski else if (bSpec)
3179*b1cdbd2cSJim Jagielski pResult = ImportGraf();
3180*b1cdbd2cSJim Jagielski
3181*b1cdbd2cSJim Jagielski // If we have a bad 0x1 insert a space instead.
3182*b1cdbd2cSJim Jagielski if (!pResult)
3183*b1cdbd2cSJim Jagielski {
3184*b1cdbd2cSJim Jagielski cInsert = ' ';
3185*b1cdbd2cSJim Jagielski ASSERT(!bObj && !bEmbeddObj && !nObjLocFc,
3186*b1cdbd2cSJim Jagielski "WW8: Please report this document, it may have a "
3187*b1cdbd2cSJim Jagielski "missing graphic");
3188*b1cdbd2cSJim Jagielski }
3189*b1cdbd2cSJim Jagielski else
3190*b1cdbd2cSJim Jagielski {
3191*b1cdbd2cSJim Jagielski // reset the flags.
3192*b1cdbd2cSJim Jagielski bObj = bEmbeddObj = false;
3193*b1cdbd2cSJim Jagielski nObjLocFc = 0;
3194*b1cdbd2cSJim Jagielski }
3195*b1cdbd2cSJim Jagielski }
3196*b1cdbd2cSJim Jagielski }
3197*b1cdbd2cSJim Jagielski break;
3198*b1cdbd2cSJim Jagielski case 0x8:
3199*b1cdbd2cSJim Jagielski if( !bObj )
3200*b1cdbd2cSJim Jagielski Read_GrafLayer( nPosCp );
3201*b1cdbd2cSJim Jagielski break;
3202*b1cdbd2cSJim Jagielski case 0xd:
3203*b1cdbd2cSJim Jagielski bNewParaEnd = bRet = true;
3204*b1cdbd2cSJim Jagielski if (nInTable > 1)
3205*b1cdbd2cSJim Jagielski {
3206*b1cdbd2cSJim Jagielski /*
3207*b1cdbd2cSJim Jagielski #i9666#/#i23161#
3208*b1cdbd2cSJim Jagielski Yes complex, if there is an entry in the undocumented PLCF
3209*b1cdbd2cSJim Jagielski which I believe to be a record of cell and row boundaries
3210*b1cdbd2cSJim Jagielski see if the magic bit which I believe to mean cell end is
3211*b1cdbd2cSJim Jagielski set. I also think btw that the third byte of the 4 byte
3212*b1cdbd2cSJim Jagielski value is the level of the cell
3213*b1cdbd2cSJim Jagielski */
3214*b1cdbd2cSJim Jagielski WW8PLCFspecial* pTest = pPlcxMan->GetMagicTables();
3215*b1cdbd2cSJim Jagielski if (pTest && pTest->SeekPosExact(nPosCp+1+nCpOfs) &&
3216*b1cdbd2cSJim Jagielski pTest->Where() == nPosCp+1+nCpOfs)
3217*b1cdbd2cSJim Jagielski {
3218*b1cdbd2cSJim Jagielski WW8_FC nPos;
3219*b1cdbd2cSJim Jagielski void *pData;
3220*b1cdbd2cSJim Jagielski pTest->Get(nPos, pData);
3221*b1cdbd2cSJim Jagielski sal_uInt32 nData = SVBT32ToUInt32(*(SVBT32*)pData);
3222*b1cdbd2cSJim Jagielski if (nData & 0x2) //Might be how it works
3223*b1cdbd2cSJim Jagielski {
3224*b1cdbd2cSJim Jagielski TabCellEnd();
3225*b1cdbd2cSJim Jagielski bRet = false;
3226*b1cdbd2cSJim Jagielski }
3227*b1cdbd2cSJim Jagielski }
3228*b1cdbd2cSJim Jagielski else if (bWasTabCellEnd)
3229*b1cdbd2cSJim Jagielski {
3230*b1cdbd2cSJim Jagielski TabCellEnd();
3231*b1cdbd2cSJim Jagielski bRet = false;
3232*b1cdbd2cSJim Jagielski }
3233*b1cdbd2cSJim Jagielski }
3234*b1cdbd2cSJim Jagielski
3235*b1cdbd2cSJim Jagielski bWasTabCellEnd = false;
3236*b1cdbd2cSJim Jagielski
3237*b1cdbd2cSJim Jagielski break; // line end
3238*b1cdbd2cSJim Jagielski case 0x5: // Annotation reference
3239*b1cdbd2cSJim Jagielski case 0x13:
3240*b1cdbd2cSJim Jagielski break;
3241*b1cdbd2cSJim Jagielski case 0x2:
3242*b1cdbd2cSJim Jagielski if (!maFtnStack.empty())
3243*b1cdbd2cSJim Jagielski cInsert = 0x2;
3244*b1cdbd2cSJim Jagielski break; // Auto-Fussnoten-Nummer
3245*b1cdbd2cSJim Jagielski #if OSL_DEBUG_LEVEL > 1
3246*b1cdbd2cSJim Jagielski default:
3247*b1cdbd2cSJim Jagielski ::std::clog << "<unknownValue val=\"" << nWCharVal << "\">" << ::std::endl;
3248*b1cdbd2cSJim Jagielski break;
3249*b1cdbd2cSJim Jagielski #endif
3250*b1cdbd2cSJim Jagielski }
3251*b1cdbd2cSJim Jagielski
3252*b1cdbd2cSJim Jagielski if( '\x0' != cInsert )
3253*b1cdbd2cSJim Jagielski {
3254*b1cdbd2cSJim Jagielski String sInsert = ByteString::ConvertToUnicode(cInsert,
3255*b1cdbd2cSJim Jagielski RTL_TEXTENCODING_MS_1252 );
3256*b1cdbd2cSJim Jagielski AddTextToParagraph(sInsert);
3257*b1cdbd2cSJim Jagielski }
3258*b1cdbd2cSJim Jagielski if (!maApos.back()) //a para end in apo doesn't count
3259*b1cdbd2cSJim Jagielski bWasParaEnd = bNewParaEnd;
3260*b1cdbd2cSJim Jagielski return bRet;
3261*b1cdbd2cSJim Jagielski }
3262*b1cdbd2cSJim Jagielski
ProcessAktCollChange(WW8PLCFManResult & rRes,bool * pStartAttr,bool bCallProcessSpecial)3263*b1cdbd2cSJim Jagielski void SwWW8ImplReader::ProcessAktCollChange(WW8PLCFManResult& rRes,
3264*b1cdbd2cSJim Jagielski bool* pStartAttr, bool bCallProcessSpecial)
3265*b1cdbd2cSJim Jagielski {
3266*b1cdbd2cSJim Jagielski sal_uInt16 nOldColl = nAktColl;
3267*b1cdbd2cSJim Jagielski nAktColl = pPlcxMan->GetColl();
3268*b1cdbd2cSJim Jagielski
3269*b1cdbd2cSJim Jagielski // Invalid Style-Id
3270*b1cdbd2cSJim Jagielski if (nAktColl >= nColls || !pCollA[nAktColl].pFmt || !pCollA[nAktColl].bColl)
3271*b1cdbd2cSJim Jagielski {
3272*b1cdbd2cSJim Jagielski nAktColl = 0;
3273*b1cdbd2cSJim Jagielski bParaAutoBefore = false;
3274*b1cdbd2cSJim Jagielski bParaAutoAfter = false;
3275*b1cdbd2cSJim Jagielski }
3276*b1cdbd2cSJim Jagielski else
3277*b1cdbd2cSJim Jagielski {
3278*b1cdbd2cSJim Jagielski bParaAutoBefore = pCollA[nAktColl].bParaAutoBefore;
3279*b1cdbd2cSJim Jagielski bParaAutoAfter = pCollA[nAktColl].bParaAutoAfter;
3280*b1cdbd2cSJim Jagielski }
3281*b1cdbd2cSJim Jagielski
3282*b1cdbd2cSJim Jagielski bool bTabRowEnd = false;
3283*b1cdbd2cSJim Jagielski if( pStartAttr && bCallProcessSpecial && !bInHyperlink )
3284*b1cdbd2cSJim Jagielski {
3285*b1cdbd2cSJim Jagielski bool bReSync;
3286*b1cdbd2cSJim Jagielski // Frame / Table / Autonumbering List Level
3287*b1cdbd2cSJim Jagielski bTabRowEnd = ProcessSpecial(bReSync, rRes.nAktCp+pPlcxMan->GetCpOfs());
3288*b1cdbd2cSJim Jagielski if( bReSync )
3289*b1cdbd2cSJim Jagielski *pStartAttr = pPlcxMan->Get( &rRes ); // hole Attribut-Pos neu
3290*b1cdbd2cSJim Jagielski }
3291*b1cdbd2cSJim Jagielski
3292*b1cdbd2cSJim Jagielski if (!bTabRowEnd && StyleExists(nAktColl))
3293*b1cdbd2cSJim Jagielski {
3294*b1cdbd2cSJim Jagielski SetTxtFmtCollAndListLevel( *pPaM, pCollA[ nAktColl ]);
3295*b1cdbd2cSJim Jagielski ChkToggleAttr(pCollA[ nOldColl ].n81Flags, pCollA[ nAktColl ].n81Flags);
3296*b1cdbd2cSJim Jagielski ChkToggleBiDiAttr(pCollA[nOldColl].n81BiDiFlags,
3297*b1cdbd2cSJim Jagielski pCollA[nAktColl].n81BiDiFlags);
3298*b1cdbd2cSJim Jagielski }
3299*b1cdbd2cSJim Jagielski }
3300*b1cdbd2cSJim Jagielski
ReadTextAttr(WW8_CP & rTxtPos,bool & rbStartLine)3301*b1cdbd2cSJim Jagielski long SwWW8ImplReader::ReadTextAttr(WW8_CP& rTxtPos, bool& rbStartLine)
3302*b1cdbd2cSJim Jagielski {
3303*b1cdbd2cSJim Jagielski long nSkipChars = 0;
3304*b1cdbd2cSJim Jagielski WW8PLCFManResult aRes;
3305*b1cdbd2cSJim Jagielski
3306*b1cdbd2cSJim Jagielski ASSERT(pPaM->GetNode()->GetTxtNode(), "Missing txtnode");
3307*b1cdbd2cSJim Jagielski bool bStartAttr = pPlcxMan->Get(&aRes); // hole Attribut-Pos
3308*b1cdbd2cSJim Jagielski aRes.nAktCp = rTxtPos; // Akt. Cp-Pos
3309*b1cdbd2cSJim Jagielski
3310*b1cdbd2cSJim Jagielski bool bNewSection = (aRes.nFlags & MAN_MASK_NEW_SEP) && !bIgnoreText;
3311*b1cdbd2cSJim Jagielski if ( bNewSection ) // neue Section
3312*b1cdbd2cSJim Jagielski {
3313*b1cdbd2cSJim Jagielski ASSERT(pPaM->GetNode()->GetTxtNode(), "Missing txtnode");
3314*b1cdbd2cSJim Jagielski // PageDesc erzeugen und fuellen
3315*b1cdbd2cSJim Jagielski maSectionManager.CreateSep(rTxtPos, bPgSecBreak);
3316*b1cdbd2cSJim Jagielski // -> 0xc war ein Sectionbreak, aber
3317*b1cdbd2cSJim Jagielski // kein Pagebreak;
3318*b1cdbd2cSJim Jagielski bPgSecBreak = false; // PageDesc erzeugen und fuellen
3319*b1cdbd2cSJim Jagielski ASSERT(pPaM->GetNode()->GetTxtNode(), "Missing txtnode");
3320*b1cdbd2cSJim Jagielski }
3321*b1cdbd2cSJim Jagielski
3322*b1cdbd2cSJim Jagielski // neuer Absatz ueber Plcx.Fkp.papx
3323*b1cdbd2cSJim Jagielski if ( (aRes.nFlags & MAN_MASK_NEW_PAP)|| rbStartLine )
3324*b1cdbd2cSJim Jagielski {
3325*b1cdbd2cSJim Jagielski ProcessAktCollChange( aRes, &bStartAttr,
3326*b1cdbd2cSJim Jagielski MAN_MASK_NEW_PAP == (aRes.nFlags & MAN_MASK_NEW_PAP) &&
3327*b1cdbd2cSJim Jagielski !bIgnoreText );
3328*b1cdbd2cSJim Jagielski rbStartLine = false;
3329*b1cdbd2cSJim Jagielski }
3330*b1cdbd2cSJim Jagielski
3331*b1cdbd2cSJim Jagielski // position of last CP that's to be ignored
3332*b1cdbd2cSJim Jagielski long nSkipPos = -1;
3333*b1cdbd2cSJim Jagielski
3334*b1cdbd2cSJim Jagielski if( 0 < aRes.nSprmId ) // leere Attrs ignorieren
3335*b1cdbd2cSJim Jagielski {
3336*b1cdbd2cSJim Jagielski if( ( eFTN > aRes.nSprmId ) || ( 0x0800 <= aRes.nSprmId ) )
3337*b1cdbd2cSJim Jagielski {
3338*b1cdbd2cSJim Jagielski if( bStartAttr ) // WW-Attribute
3339*b1cdbd2cSJim Jagielski {
3340*b1cdbd2cSJim Jagielski if( aRes.nMemLen >= 0 )
3341*b1cdbd2cSJim Jagielski ImportSprm(aRes.pMemPos, aRes.nSprmId);
3342*b1cdbd2cSJim Jagielski }
3343*b1cdbd2cSJim Jagielski else
3344*b1cdbd2cSJim Jagielski EndSprm( aRes.nSprmId ); // Attr ausschalten
3345*b1cdbd2cSJim Jagielski }
3346*b1cdbd2cSJim Jagielski else if( aRes.nSprmId < 0x800 ) // eigene Hilfs-Attribute
3347*b1cdbd2cSJim Jagielski {
3348*b1cdbd2cSJim Jagielski if (bStartAttr)
3349*b1cdbd2cSJim Jagielski {
3350*b1cdbd2cSJim Jagielski nSkipChars = ImportExtSprm(&aRes);
3351*b1cdbd2cSJim Jagielski if (
3352*b1cdbd2cSJim Jagielski (aRes.nSprmId == eFTN) || (aRes.nSprmId == eEDN) ||
3353*b1cdbd2cSJim Jagielski (aRes.nSprmId == eFLD) || (aRes.nSprmId == eAND)
3354*b1cdbd2cSJim Jagielski )
3355*b1cdbd2cSJim Jagielski {
3356*b1cdbd2cSJim Jagielski // Felder/Ftn-/End-Note hier ueberlesen
3357*b1cdbd2cSJim Jagielski rTxtPos += nSkipChars;
3358*b1cdbd2cSJim Jagielski nSkipPos = rTxtPos-1;
3359*b1cdbd2cSJim Jagielski }
3360*b1cdbd2cSJim Jagielski }
3361*b1cdbd2cSJim Jagielski else
3362*b1cdbd2cSJim Jagielski EndExtSprm( aRes.nSprmId );
3363*b1cdbd2cSJim Jagielski }
3364*b1cdbd2cSJim Jagielski }
3365*b1cdbd2cSJim Jagielski
3366*b1cdbd2cSJim Jagielski pStrm->Seek(pSBase->WW8Cp2Fc( pPlcxMan->GetCpOfs() + rTxtPos, &bIsUnicode));
3367*b1cdbd2cSJim Jagielski
3368*b1cdbd2cSJim Jagielski // Find next Attr position (and Skip attributes of field contents if needed)
3369*b1cdbd2cSJim Jagielski if (nSkipChars && !bIgnoreText)
3370*b1cdbd2cSJim Jagielski pCtrlStck->MarkAllAttrsOld();
3371*b1cdbd2cSJim Jagielski bool bOldIgnoreText = bIgnoreText;
3372*b1cdbd2cSJim Jagielski bIgnoreText = true;
3373*b1cdbd2cSJim Jagielski sal_uInt16 nOldColl = nAktColl;
3374*b1cdbd2cSJim Jagielski bool bDoPlcxManPlusPLus = true;
3375*b1cdbd2cSJim Jagielski long nNext;
3376*b1cdbd2cSJim Jagielski do
3377*b1cdbd2cSJim Jagielski {
3378*b1cdbd2cSJim Jagielski if( bDoPlcxManPlusPLus )
3379*b1cdbd2cSJim Jagielski (*pPlcxMan)++;
3380*b1cdbd2cSJim Jagielski nNext = pPlcxMan->Where();
3381*b1cdbd2cSJim Jagielski
3382*b1cdbd2cSJim Jagielski if (mpPostProcessAttrsInfo &&
3383*b1cdbd2cSJim Jagielski mpPostProcessAttrsInfo->mnCpStart == nNext)
3384*b1cdbd2cSJim Jagielski {
3385*b1cdbd2cSJim Jagielski mpPostProcessAttrsInfo->mbCopy = true;
3386*b1cdbd2cSJim Jagielski }
3387*b1cdbd2cSJim Jagielski
3388*b1cdbd2cSJim Jagielski if( (0 <= nNext) && (nSkipPos >= nNext) )
3389*b1cdbd2cSJim Jagielski {
3390*b1cdbd2cSJim Jagielski nNext = ReadTextAttr( rTxtPos, rbStartLine );
3391*b1cdbd2cSJim Jagielski bDoPlcxManPlusPLus = false;
3392*b1cdbd2cSJim Jagielski bIgnoreText = true;
3393*b1cdbd2cSJim Jagielski }
3394*b1cdbd2cSJim Jagielski
3395*b1cdbd2cSJim Jagielski if (mpPostProcessAttrsInfo &&
3396*b1cdbd2cSJim Jagielski nNext > mpPostProcessAttrsInfo->mnCpEnd)
3397*b1cdbd2cSJim Jagielski {
3398*b1cdbd2cSJim Jagielski mpPostProcessAttrsInfo->mbCopy = false;
3399*b1cdbd2cSJim Jagielski }
3400*b1cdbd2cSJim Jagielski }
3401*b1cdbd2cSJim Jagielski while( nSkipPos >= nNext );
3402*b1cdbd2cSJim Jagielski bIgnoreText = bOldIgnoreText;
3403*b1cdbd2cSJim Jagielski if( nSkipChars )
3404*b1cdbd2cSJim Jagielski {
3405*b1cdbd2cSJim Jagielski pCtrlStck->KillUnlockedAttrs( *pPaM->GetPoint() );
3406*b1cdbd2cSJim Jagielski if( nOldColl != pPlcxMan->GetColl() )
3407*b1cdbd2cSJim Jagielski ProcessAktCollChange(aRes, 0, false);
3408*b1cdbd2cSJim Jagielski }
3409*b1cdbd2cSJim Jagielski
3410*b1cdbd2cSJim Jagielski return nNext;
3411*b1cdbd2cSJim Jagielski }
3412*b1cdbd2cSJim Jagielski //Modify here for #119405, by easyfan, 2012-05-24
3413*b1cdbd2cSJim Jagielski //Revised 2012.8.16 for the complex attribute presentation of 0x0D in MS
IsParaEndInCPs(sal_Int32 nStart,sal_Int32 nEnd,bool bSdOD) const3414*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::IsParaEndInCPs(sal_Int32 nStart, sal_Int32 nEnd,bool bSdOD) const
3415*b1cdbd2cSJim Jagielski {
3416*b1cdbd2cSJim Jagielski //Modify for #119405 by chengjh, 2012-08-16
3417*b1cdbd2cSJim Jagielski //Revised for performance consideration
3418*b1cdbd2cSJim Jagielski if (nStart == -1 || nEnd == -1 || nEnd < nStart )
3419*b1cdbd2cSJim Jagielski return false;
3420*b1cdbd2cSJim Jagielski
3421*b1cdbd2cSJim Jagielski for (cp_vector::const_reverse_iterator aItr = maEndParaPos.rbegin(); aItr!= maEndParaPos.rend(); aItr++)
3422*b1cdbd2cSJim Jagielski //End
3423*b1cdbd2cSJim Jagielski {
3424*b1cdbd2cSJim Jagielski //Revised 2012.8.16,to the 0x0D,the attribute will have two situations
3425*b1cdbd2cSJim Jagielski //*********within***********exact******//
3426*b1cdbd2cSJim Jagielski //*********but also sample with only left and the position of 0x0d is the edge of the right side***********//
3427*b1cdbd2cSJim Jagielski if ( bSdOD && ( (nStart < *aItr && nEnd > *aItr) || ( nStart == nEnd && *aItr == nStart)) )
3428*b1cdbd2cSJim Jagielski return true;
3429*b1cdbd2cSJim Jagielski else if ( !bSdOD && (nStart < *aItr && nEnd >= *aItr) )
3430*b1cdbd2cSJim Jagielski return true;
3431*b1cdbd2cSJim Jagielski }
3432*b1cdbd2cSJim Jagielski
3433*b1cdbd2cSJim Jagielski return false;
3434*b1cdbd2cSJim Jagielski }
3435*b1cdbd2cSJim Jagielski //End of modification, by easyfan
3436*b1cdbd2cSJim Jagielski //Modify for #119405 by chengjh, 2012-08-16
3437*b1cdbd2cSJim Jagielski //Clear the para end position recorded in reader intermittently for the least impact on loading performance
ClearParaEndPosition()3438*b1cdbd2cSJim Jagielski void SwWW8ImplReader::ClearParaEndPosition()
3439*b1cdbd2cSJim Jagielski {
3440*b1cdbd2cSJim Jagielski if ( maEndParaPos.size() > 0 )
3441*b1cdbd2cSJim Jagielski maEndParaPos.clear();
3442*b1cdbd2cSJim Jagielski }
3443*b1cdbd2cSJim Jagielski //End
ReadAttrs(WW8_CP & rNext,WW8_CP & rTxtPos,bool & rbStartLine)3444*b1cdbd2cSJim Jagielski void SwWW8ImplReader::ReadAttrs(WW8_CP& rNext, WW8_CP& rTxtPos, bool& rbStartLine)
3445*b1cdbd2cSJim Jagielski {
3446*b1cdbd2cSJim Jagielski if( rTxtPos >= rNext )
3447*b1cdbd2cSJim Jagielski { // Stehen Attribute an ?
3448*b1cdbd2cSJim Jagielski
3449*b1cdbd2cSJim Jagielski do
3450*b1cdbd2cSJim Jagielski {
3451*b1cdbd2cSJim Jagielski //Modify here for #119405, by easyfan, 2012-05-24
3452*b1cdbd2cSJim Jagielski maCurrAttrCP = rTxtPos;
3453*b1cdbd2cSJim Jagielski //End of modification, by easyfan
3454*b1cdbd2cSJim Jagielski rNext = ReadTextAttr( rTxtPos, rbStartLine );
3455*b1cdbd2cSJim Jagielski }
3456*b1cdbd2cSJim Jagielski while( rTxtPos >= rNext );
3457*b1cdbd2cSJim Jagielski
3458*b1cdbd2cSJim Jagielski }
3459*b1cdbd2cSJim Jagielski else if ( rbStartLine )
3460*b1cdbd2cSJim Jagielski {
3461*b1cdbd2cSJim Jagielski // keine Attribute, aber trotzdem neue Zeile
3462*b1cdbd2cSJim Jagielski // wenn eine Zeile mit einem Seitenumbruch aufhoert und sich keine
3463*b1cdbd2cSJim Jagielski // Absatzattribute / Absatzvorlagen aendern, ist das Zeilenende
3464*b1cdbd2cSJim Jagielski // nicht im Plcx.Fkp.papx eingetragen, d.h. ( nFlags & MAN_MASK_NEW_PAP )
3465*b1cdbd2cSJim Jagielski // ist false. Deshalb muss als Sonderbehandlung hier die Vorlage gesetzt
3466*b1cdbd2cSJim Jagielski // werden.
3467*b1cdbd2cSJim Jagielski if (!bCpxStyle && nAktColl < nColls)
3468*b1cdbd2cSJim Jagielski SetTxtFmtCollAndListLevel(*pPaM, pCollA[nAktColl]);
3469*b1cdbd2cSJim Jagielski rbStartLine = false;
3470*b1cdbd2cSJim Jagielski }
3471*b1cdbd2cSJim Jagielski }
3472*b1cdbd2cSJim Jagielski
3473*b1cdbd2cSJim Jagielski // CloseAttrEnds zum Lesen nur der Attributenden am Ende eines Textes oder
3474*b1cdbd2cSJim Jagielski // Textbereiches ( Kopfzeile, Fussnote, ...). Attributanfaenge, Felder
3475*b1cdbd2cSJim Jagielski // werden ignoriert.
CloseAttrEnds()3476*b1cdbd2cSJim Jagielski void SwWW8ImplReader::CloseAttrEnds()
3477*b1cdbd2cSJim Jagielski {
3478*b1cdbd2cSJim Jagielski //If there are any unclosed sprms then copy them to
3479*b1cdbd2cSJim Jagielski //another stack and close the ones that must be closed
3480*b1cdbd2cSJim Jagielski std::stack<sal_uInt16> aStack;
3481*b1cdbd2cSJim Jagielski pPlcxMan->TransferOpenSprms(aStack);
3482*b1cdbd2cSJim Jagielski
3483*b1cdbd2cSJim Jagielski while (!aStack.empty())
3484*b1cdbd2cSJim Jagielski {
3485*b1cdbd2cSJim Jagielski sal_uInt16 nSprmId = aStack.top();
3486*b1cdbd2cSJim Jagielski if ((0 < nSprmId) && (( eFTN > nSprmId) || (0x0800 <= nSprmId)))
3487*b1cdbd2cSJim Jagielski EndSprm(nSprmId);
3488*b1cdbd2cSJim Jagielski aStack.pop();
3489*b1cdbd2cSJim Jagielski }
3490*b1cdbd2cSJim Jagielski
3491*b1cdbd2cSJim Jagielski EndSpecial();
3492*b1cdbd2cSJim Jagielski }
3493*b1cdbd2cSJim Jagielski
ReadText(long nStartCp,long nTextLen,ManTypes nType)3494*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::ReadText(long nStartCp, long nTextLen, ManTypes nType)
3495*b1cdbd2cSJim Jagielski {
3496*b1cdbd2cSJim Jagielski sw::log::Environment eContext = sw::log::eMainText;
3497*b1cdbd2cSJim Jagielski if (nType == MAN_MAINTEXT)
3498*b1cdbd2cSJim Jagielski eContext = sw::log::eMainText;
3499*b1cdbd2cSJim Jagielski else
3500*b1cdbd2cSJim Jagielski eContext = sw::log::eSubDoc;
3501*b1cdbd2cSJim Jagielski maTracer.EnterEnvironment(eContext);
3502*b1cdbd2cSJim Jagielski
3503*b1cdbd2cSJim Jagielski bool bJoined=false;
3504*b1cdbd2cSJim Jagielski
3505*b1cdbd2cSJim Jagielski bool bStartLine = true;
3506*b1cdbd2cSJim Jagielski short nCrCount = 0;
3507*b1cdbd2cSJim Jagielski short nDistance = 0;
3508*b1cdbd2cSJim Jagielski
3509*b1cdbd2cSJim Jagielski bWasParaEnd = false;
3510*b1cdbd2cSJim Jagielski nAktColl = 0;
3511*b1cdbd2cSJim Jagielski pAktItemSet = 0;
3512*b1cdbd2cSJim Jagielski nCharFmt = -1;
3513*b1cdbd2cSJim Jagielski bSpec = false;
3514*b1cdbd2cSJim Jagielski bPgSecBreak = false;
3515*b1cdbd2cSJim Jagielski
3516*b1cdbd2cSJim Jagielski pPlcxMan = new WW8PLCFMan( pSBase, nType, nStartCp );
3517*b1cdbd2cSJim Jagielski long nCpOfs = pPlcxMan->GetCpOfs(); // Offset fuer Header/Footer, Footnote
3518*b1cdbd2cSJim Jagielski
3519*b1cdbd2cSJim Jagielski WW8_CP nNext = pPlcxMan->Where();
3520*b1cdbd2cSJim Jagielski SwTxtNode* pPreviousNode = 0;
3521*b1cdbd2cSJim Jagielski sal_uInt8 nDropLines = 0;
3522*b1cdbd2cSJim Jagielski SwCharFmt* pNewSwCharFmt = 0;
3523*b1cdbd2cSJim Jagielski const SwCharFmt* pFmt = 0;
3524*b1cdbd2cSJim Jagielski pStrm->Seek( pSBase->WW8Cp2Fc( nStartCp + nCpOfs, &bIsUnicode ) );
3525*b1cdbd2cSJim Jagielski
3526*b1cdbd2cSJim Jagielski WW8_CP l = nStartCp;
3527*b1cdbd2cSJim Jagielski while ( l<nStartCp+nTextLen )
3528*b1cdbd2cSJim Jagielski {
3529*b1cdbd2cSJim Jagielski ReadAttrs( nNext, l, bStartLine );// behandelt auch Section-Breaks
3530*b1cdbd2cSJim Jagielski ASSERT(pPaM->GetNode()->GetTxtNode(), "Missing txtnode");
3531*b1cdbd2cSJim Jagielski
3532*b1cdbd2cSJim Jagielski if (mpPostProcessAttrsInfo != NULL)
3533*b1cdbd2cSJim Jagielski PostProcessAttrs();
3534*b1cdbd2cSJim Jagielski
3535*b1cdbd2cSJim Jagielski if( l>= nStartCp + nTextLen )
3536*b1cdbd2cSJim Jagielski break;
3537*b1cdbd2cSJim Jagielski
3538*b1cdbd2cSJim Jagielski bStartLine = ReadChars(l, nNext, nStartCp+nTextLen, nCpOfs);
3539*b1cdbd2cSJim Jagielski
3540*b1cdbd2cSJim Jagielski // If the previous paragraph was a dropcap then do not
3541*b1cdbd2cSJim Jagielski // create a new txtnode and join the two paragraphs together
3542*b1cdbd2cSJim Jagielski
3543*b1cdbd2cSJim Jagielski if (bStartLine && !pPreviousNode) // Zeilenende
3544*b1cdbd2cSJim Jagielski {
3545*b1cdbd2cSJim Jagielski bool bSplit = true;
3546*b1cdbd2cSJim Jagielski if (mbCareFirstParaEndInToc)
3547*b1cdbd2cSJim Jagielski {
3548*b1cdbd2cSJim Jagielski mbCareFirstParaEndInToc = false;
3549*b1cdbd2cSJim Jagielski if (pPaM->End() && pPaM->End()->nNode.GetNode().GetTxtNode() && pPaM->End()->nNode.GetNode().GetTxtNode()->Len() == 0)
3550*b1cdbd2cSJim Jagielski bSplit = false;
3551*b1cdbd2cSJim Jagielski }
3552*b1cdbd2cSJim Jagielski if (mbCareLastParaEndInToc)
3553*b1cdbd2cSJim Jagielski {
3554*b1cdbd2cSJim Jagielski mbCareLastParaEndInToc = false;
3555*b1cdbd2cSJim Jagielski if (pPaM->End() && pPaM->End()->nNode.GetNode().GetTxtNode() && pPaM->End()->nNode.GetNode().GetTxtNode()->Len() == 0)
3556*b1cdbd2cSJim Jagielski bSplit = false;
3557*b1cdbd2cSJim Jagielski }
3558*b1cdbd2cSJim Jagielski if (bSplit)
3559*b1cdbd2cSJim Jagielski {
3560*b1cdbd2cSJim Jagielski // #119405# - We will record the CP of a paragraph end ('0x0D'), if current loading contents is from main stream;
3561*b1cdbd2cSJim Jagielski if (mbOnLoadingMain)
3562*b1cdbd2cSJim Jagielski maEndParaPos.push_back(l-1);
3563*b1cdbd2cSJim Jagielski AppendTxtNode(*pPaM->GetPoint());
3564*b1cdbd2cSJim Jagielski }
3565*b1cdbd2cSJim Jagielski }
3566*b1cdbd2cSJim Jagielski
3567*b1cdbd2cSJim Jagielski if (pPreviousNode && bStartLine)
3568*b1cdbd2cSJim Jagielski {
3569*b1cdbd2cSJim Jagielski SwTxtNode* pEndNd = pPaM->GetNode()->GetTxtNode();
3570*b1cdbd2cSJim Jagielski const xub_StrLen nDropCapLen = pPreviousNode->GetTxt().Len();
3571*b1cdbd2cSJim Jagielski
3572*b1cdbd2cSJim Jagielski // Need to reset the font size and text position for the dropcap
3573*b1cdbd2cSJim Jagielski {
3574*b1cdbd2cSJim Jagielski SwPaM aTmp(*pEndNd, 0, *pEndNd, nDropCapLen+1);
3575*b1cdbd2cSJim Jagielski pCtrlStck->Delete(aTmp);
3576*b1cdbd2cSJim Jagielski }
3577*b1cdbd2cSJim Jagielski
3578*b1cdbd2cSJim Jagielski // Get the default document dropcap which we can use as our template
3579*b1cdbd2cSJim Jagielski const SwFmtDrop* defaultDrop =
3580*b1cdbd2cSJim Jagielski (const SwFmtDrop*) GetFmtAttr(RES_PARATR_DROP);
3581*b1cdbd2cSJim Jagielski SwFmtDrop aDrop(*defaultDrop);
3582*b1cdbd2cSJim Jagielski
3583*b1cdbd2cSJim Jagielski aDrop.GetLines() = nDropLines;
3584*b1cdbd2cSJim Jagielski aDrop.GetDistance() = nDistance;
3585*b1cdbd2cSJim Jagielski aDrop.GetChars() = writer_cast<sal_uInt8>(nDropCapLen);
3586*b1cdbd2cSJim Jagielski // Word has no concept of a "whole word dropcap"
3587*b1cdbd2cSJim Jagielski aDrop.GetWholeWord() = false;
3588*b1cdbd2cSJim Jagielski
3589*b1cdbd2cSJim Jagielski if (pFmt)
3590*b1cdbd2cSJim Jagielski aDrop.SetCharFmt(const_cast<SwCharFmt*>(pFmt));
3591*b1cdbd2cSJim Jagielski else if(pNewSwCharFmt)
3592*b1cdbd2cSJim Jagielski aDrop.SetCharFmt(const_cast<SwCharFmt*>(pNewSwCharFmt));
3593*b1cdbd2cSJim Jagielski
3594*b1cdbd2cSJim Jagielski SwPosition aStart(*pEndNd);
3595*b1cdbd2cSJim Jagielski pCtrlStck->NewAttr(aStart, aDrop);
3596*b1cdbd2cSJim Jagielski pCtrlStck->SetAttr(*pPaM->GetPoint(), RES_PARATR_DROP);
3597*b1cdbd2cSJim Jagielski pPreviousNode = 0;
3598*b1cdbd2cSJim Jagielski }
3599*b1cdbd2cSJim Jagielski else if (bDropCap)
3600*b1cdbd2cSJim Jagielski {
3601*b1cdbd2cSJim Jagielski // If we have found a dropcap store the textnode
3602*b1cdbd2cSJim Jagielski pPreviousNode = pPaM->GetNode()->GetTxtNode();
3603*b1cdbd2cSJim Jagielski
3604*b1cdbd2cSJim Jagielski const sal_uInt8 *pDCS;
3605*b1cdbd2cSJim Jagielski
3606*b1cdbd2cSJim Jagielski if (bVer67)
3607*b1cdbd2cSJim Jagielski pDCS = pPlcxMan->GetPapPLCF()->HasSprm(46);
3608*b1cdbd2cSJim Jagielski else
3609*b1cdbd2cSJim Jagielski pDCS = pPlcxMan->GetPapPLCF()->HasSprm(0x442C);
3610*b1cdbd2cSJim Jagielski
3611*b1cdbd2cSJim Jagielski if (pDCS)
3612*b1cdbd2cSJim Jagielski nDropLines = (*pDCS) >> 3;
3613*b1cdbd2cSJim Jagielski else // There is no Drop Cap Specifier hence no dropcap
3614*b1cdbd2cSJim Jagielski pPreviousNode = 0;
3615*b1cdbd2cSJim Jagielski
3616*b1cdbd2cSJim Jagielski if (const sal_uInt8 *pDistance = pPlcxMan->GetPapPLCF()->HasSprm(0x842F))
3617*b1cdbd2cSJim Jagielski nDistance = SVBT16ToShort( pDistance );
3618*b1cdbd2cSJim Jagielski else
3619*b1cdbd2cSJim Jagielski nDistance = 0;
3620*b1cdbd2cSJim Jagielski
3621*b1cdbd2cSJim Jagielski const SwFmtCharFmt *pSwFmtCharFmt = 0;
3622*b1cdbd2cSJim Jagielski
3623*b1cdbd2cSJim Jagielski if(pAktItemSet)
3624*b1cdbd2cSJim Jagielski pSwFmtCharFmt = &(ItemGet<SwFmtCharFmt>(*pAktItemSet, RES_TXTATR_CHARFMT));
3625*b1cdbd2cSJim Jagielski
3626*b1cdbd2cSJim Jagielski if(pSwFmtCharFmt)
3627*b1cdbd2cSJim Jagielski pFmt = pSwFmtCharFmt->GetCharFmt();
3628*b1cdbd2cSJim Jagielski
3629*b1cdbd2cSJim Jagielski if(pAktItemSet && !pFmt)
3630*b1cdbd2cSJim Jagielski {
3631*b1cdbd2cSJim Jagielski String sPrefix(CREATE_CONST_ASC( "WW8Dropcap"));
3632*b1cdbd2cSJim Jagielski sPrefix += String::CreateFromInt32( nDropCap++ );
3633*b1cdbd2cSJim Jagielski pNewSwCharFmt = rDoc.MakeCharFmt(sPrefix, (SwCharFmt*)rDoc.GetDfltCharFmt());
3634*b1cdbd2cSJim Jagielski pAktItemSet->ClearItem(RES_CHRATR_ESCAPEMENT);
3635*b1cdbd2cSJim Jagielski pNewSwCharFmt->SetFmtAttr( *pAktItemSet );
3636*b1cdbd2cSJim Jagielski }
3637*b1cdbd2cSJim Jagielski
3638*b1cdbd2cSJim Jagielski delete pAktItemSet;
3639*b1cdbd2cSJim Jagielski pAktItemSet = 0;
3640*b1cdbd2cSJim Jagielski bDropCap=false;
3641*b1cdbd2cSJim Jagielski }
3642*b1cdbd2cSJim Jagielski
3643*b1cdbd2cSJim Jagielski if (bStartLine || bWasTabRowEnd)
3644*b1cdbd2cSJim Jagielski {
3645*b1cdbd2cSJim Jagielski // alle 64 CRs aufrufen not for Header u. ae.
3646*b1cdbd2cSJim Jagielski if ((nCrCount++ & 0x40) == 0 && nType == MAN_MAINTEXT)
3647*b1cdbd2cSJim Jagielski {
3648*b1cdbd2cSJim Jagielski nProgress = (sal_uInt16)( l * 100 / nTextLen );
3649*b1cdbd2cSJim Jagielski ::SetProgressState(nProgress, mpDocShell); // Update
3650*b1cdbd2cSJim Jagielski }
3651*b1cdbd2cSJim Jagielski }
3652*b1cdbd2cSJim Jagielski
3653*b1cdbd2cSJim Jagielski // If we have encountered a 0x0c which indicates either section of
3654*b1cdbd2cSJim Jagielski // pagebreak then look it up to see if it is a section break, and
3655*b1cdbd2cSJim Jagielski // if it is not then insert a page break. If it is a section break
3656*b1cdbd2cSJim Jagielski // it will be handled as such in the ReadAttrs of the next loop
3657*b1cdbd2cSJim Jagielski if (bPgSecBreak)
3658*b1cdbd2cSJim Jagielski {
3659*b1cdbd2cSJim Jagielski // We need only to see if a section is ending at this cp,
3660*b1cdbd2cSJim Jagielski // the plcf will already be sitting on the correct location
3661*b1cdbd2cSJim Jagielski // if it is there.
3662*b1cdbd2cSJim Jagielski WW8PLCFxDesc aTemp;
3663*b1cdbd2cSJim Jagielski aTemp.nStartPos = aTemp.nEndPos = WW8_CP_MAX;
3664*b1cdbd2cSJim Jagielski if (pPlcxMan->GetSepPLCF())
3665*b1cdbd2cSJim Jagielski pPlcxMan->GetSepPLCF()->GetSprms(&aTemp);
3666*b1cdbd2cSJim Jagielski if ((aTemp.nStartPos != l) && (aTemp.nEndPos != l))
3667*b1cdbd2cSJim Jagielski {
3668*b1cdbd2cSJim Jagielski // #i39251# - insert text node for page break, if no one inserted.
3669*b1cdbd2cSJim Jagielski // #i43118# - refine condition: the anchor control stack has to have entries,
3670*b1cdbd2cSJim Jagielski // otherwise it's not needed to insert a text node.
3671*b1cdbd2cSJim Jagielski if ( !bStartLine && pAnchorStck->Count() > 0 )
3672*b1cdbd2cSJim Jagielski {
3673*b1cdbd2cSJim Jagielski AppendTxtNode(*pPaM->GetPoint());
3674*b1cdbd2cSJim Jagielski }
3675*b1cdbd2cSJim Jagielski rDoc.InsertPoolItem(*pPaM,
3676*b1cdbd2cSJim Jagielski SvxFmtBreakItem(SVX_BREAK_PAGE_BEFORE, RES_BREAK), 0);
3677*b1cdbd2cSJim Jagielski bFirstParaOfPage = true;//xushanchuan add for issue106569
3678*b1cdbd2cSJim Jagielski bPgSecBreak = false;
3679*b1cdbd2cSJim Jagielski }
3680*b1cdbd2cSJim Jagielski }
3681*b1cdbd2cSJim Jagielski }
3682*b1cdbd2cSJim Jagielski
3683*b1cdbd2cSJim Jagielski if (pPaM->GetPoint()->nContent.GetIndex())
3684*b1cdbd2cSJim Jagielski AppendTxtNode(*pPaM->GetPoint());
3685*b1cdbd2cSJim Jagielski
3686*b1cdbd2cSJim Jagielski if (!bInHyperlink)
3687*b1cdbd2cSJim Jagielski bJoined = JoinNode(*pPaM);
3688*b1cdbd2cSJim Jagielski
3689*b1cdbd2cSJim Jagielski CloseAttrEnds();
3690*b1cdbd2cSJim Jagielski
3691*b1cdbd2cSJim Jagielski delete pPlcxMan, pPlcxMan = 0;
3692*b1cdbd2cSJim Jagielski maTracer.LeaveEnvironment(eContext);
3693*b1cdbd2cSJim Jagielski return bJoined;
3694*b1cdbd2cSJim Jagielski }
3695*b1cdbd2cSJim Jagielski
3696*b1cdbd2cSJim Jagielski /***************************************************************************
3697*b1cdbd2cSJim Jagielski # class SwWW8ImplReader
3698*b1cdbd2cSJim Jagielski #**************************************************************************/
3699*b1cdbd2cSJim Jagielski
SwWW8ImplReader(sal_uInt8 nVersionPara,SvStorage * pStorage,SvStream * pSt,SwDoc & rD,const String & rBaseURL,bool bNewDoc)3700*b1cdbd2cSJim Jagielski SwWW8ImplReader::SwWW8ImplReader(sal_uInt8 nVersionPara, SvStorage* pStorage,
3701*b1cdbd2cSJim Jagielski SvStream* pSt, SwDoc& rD, const String& rBaseURL, bool bNewDoc)
3702*b1cdbd2cSJim Jagielski : mpDocShell(rD.GetDocShell())
3703*b1cdbd2cSJim Jagielski , maTracer(*(mpDocShell->GetMedium()))
3704*b1cdbd2cSJim Jagielski , pStg(pStorage)
3705*b1cdbd2cSJim Jagielski , pStrm(pSt)
3706*b1cdbd2cSJim Jagielski , pTableStream(0)
3707*b1cdbd2cSJim Jagielski , pDataStream(0)
3708*b1cdbd2cSJim Jagielski , rDoc(rD)
3709*b1cdbd2cSJim Jagielski , maSectionManager(*this)
3710*b1cdbd2cSJim Jagielski , maInsertedTables(rD)
3711*b1cdbd2cSJim Jagielski , maSectionNameGenerator(rD,CREATE_CONST_ASC("WW"))
3712*b1cdbd2cSJim Jagielski , maGrfNameGenerator(bNewDoc,String('G'))
3713*b1cdbd2cSJim Jagielski , maParaStyleMapper(rD)
3714*b1cdbd2cSJim Jagielski , maCharStyleMapper(rD)
3715*b1cdbd2cSJim Jagielski , maTxtNodesHavingFirstLineOfstSet()
3716*b1cdbd2cSJim Jagielski , maTxtNodesHavingLeftIndentSet()
3717*b1cdbd2cSJim Jagielski , pMSDffManager(0)
3718*b1cdbd2cSJim Jagielski , mpAtnNames(0)
3719*b1cdbd2cSJim Jagielski , pAuthorInfos(0)
3720*b1cdbd2cSJim Jagielski , sBaseURL(rBaseURL)
3721*b1cdbd2cSJim Jagielski , m_bRegardHindiDigits( false )
3722*b1cdbd2cSJim Jagielski , mbNewDoc(bNewDoc)
3723*b1cdbd2cSJim Jagielski , nDropCap(0)
3724*b1cdbd2cSJim Jagielski , nIdctHint(0)
3725*b1cdbd2cSJim Jagielski , bBidi(false)
3726*b1cdbd2cSJim Jagielski , bReadTable(false)
3727*b1cdbd2cSJim Jagielski , mbLoadingTOCCache(false)
3728*b1cdbd2cSJim Jagielski , mbLoadingTOCHyperlink(false)
3729*b1cdbd2cSJim Jagielski , mpPosAfterTOC(0)
3730*b1cdbd2cSJim Jagielski , mbCareFirstParaEndInToc(false)
3731*b1cdbd2cSJim Jagielski , mbCareLastParaEndInToc(false)
3732*b1cdbd2cSJim Jagielski , maTOXEndCps()
3733*b1cdbd2cSJim Jagielski //Modify here for #119405, by easyfan, 2012-05-24
3734*b1cdbd2cSJim Jagielski ,maCurrAttrCP(-1),
3735*b1cdbd2cSJim Jagielski mbOnLoadingMain(false)
3736*b1cdbd2cSJim Jagielski //End of modification, by easyfan
3737*b1cdbd2cSJim Jagielski {
3738*b1cdbd2cSJim Jagielski pStrm->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
3739*b1cdbd2cSJim Jagielski nWantedVersion = nVersionPara;
3740*b1cdbd2cSJim Jagielski pCtrlStck = 0;
3741*b1cdbd2cSJim Jagielski mpRedlineStack = 0;
3742*b1cdbd2cSJim Jagielski pReffedStck = 0;
3743*b1cdbd2cSJim Jagielski pReffingStck = 0;
3744*b1cdbd2cSJim Jagielski pAnchorStck = 0;
3745*b1cdbd2cSJim Jagielski pFonts = 0;
3746*b1cdbd2cSJim Jagielski pSBase = 0;
3747*b1cdbd2cSJim Jagielski pPlcxMan = 0;
3748*b1cdbd2cSJim Jagielski pStyles = 0;
3749*b1cdbd2cSJim Jagielski pAktColl = 0;
3750*b1cdbd2cSJim Jagielski pLstManager = 0;
3751*b1cdbd2cSJim Jagielski pAktItemSet = 0;
3752*b1cdbd2cSJim Jagielski pCollA = 0;
3753*b1cdbd2cSJim Jagielski pDfltTxtFmtColl = 0;
3754*b1cdbd2cSJim Jagielski pStandardFmtColl = 0;
3755*b1cdbd2cSJim Jagielski pHdFt = 0;
3756*b1cdbd2cSJim Jagielski pWFlyPara = 0;
3757*b1cdbd2cSJim Jagielski pSFlyPara = 0;
3758*b1cdbd2cSJim Jagielski pFlyFmtOfJustInsertedGraphic = 0;
3759*b1cdbd2cSJim Jagielski pFmtOfJustInsertedApo = 0;
3760*b1cdbd2cSJim Jagielski pPreviousNumPaM = 0;
3761*b1cdbd2cSJim Jagielski pPrevNumRule = 0;
3762*b1cdbd2cSJim Jagielski nColls = nAktColl = 0;
3763*b1cdbd2cSJim Jagielski nObjLocFc = nPicLocFc = 0;
3764*b1cdbd2cSJim Jagielski nInTable=0;
3765*b1cdbd2cSJim Jagielski bReadNoTbl = bPgSecBreak = bSpec = bObj = bTxbxFlySection
3766*b1cdbd2cSJim Jagielski = bHasBorder = bSymbol = bIgnoreText
3767*b1cdbd2cSJim Jagielski = bWasTabRowEnd = bWasTabCellEnd = false;
3768*b1cdbd2cSJim Jagielski bShdTxtCol = bCharShdTxtCol = bAnl = bHdFtFtnEdn = bFtnEdn
3769*b1cdbd2cSJim Jagielski = bIsHeader = bIsFooter = bIsUnicode = bCpxStyle = bStyNormal =
3770*b1cdbd2cSJim Jagielski bWWBugNormal = false;
3771*b1cdbd2cSJim Jagielski
3772*b1cdbd2cSJim Jagielski mpPostProcessAttrsInfo = 0;
3773*b1cdbd2cSJim Jagielski
3774*b1cdbd2cSJim Jagielski bNoAttrImport = bPgChpLevel = bEmbeddObj = false;
3775*b1cdbd2cSJim Jagielski bAktAND_fNumberAcross = false;
3776*b1cdbd2cSJim Jagielski bNoLnNumYet = true;
3777*b1cdbd2cSJim Jagielski bInHyperlink = false;
3778*b1cdbd2cSJim Jagielski bWasParaEnd = false;
3779*b1cdbd2cSJim Jagielski bDropCap = false;
3780*b1cdbd2cSJim Jagielski bFirstPara = true;
3781*b1cdbd2cSJim Jagielski bFirstParaOfPage = false;//xushanchuan add for issue106569
3782*b1cdbd2cSJim Jagielski bParaAutoBefore = false;
3783*b1cdbd2cSJim Jagielski bParaAutoAfter = false;
3784*b1cdbd2cSJim Jagielski nProgress = 0;
3785*b1cdbd2cSJim Jagielski nSwNumLevel = nWwNumType = 0xff;
3786*b1cdbd2cSJim Jagielski pTableDesc = 0;
3787*b1cdbd2cSJim Jagielski pNumOlst = 0;
3788*b1cdbd2cSJim Jagielski pNode_FLY_AT_PARA = 0;
3789*b1cdbd2cSJim Jagielski pDrawModel = 0;
3790*b1cdbd2cSJim Jagielski pDrawPg = 0;
3791*b1cdbd2cSJim Jagielski mpDrawEditEngine = 0;
3792*b1cdbd2cSJim Jagielski pWWZOrder = 0;
3793*b1cdbd2cSJim Jagielski pFormImpl = 0;
3794*b1cdbd2cSJim Jagielski pNumFldType = 0;
3795*b1cdbd2cSJim Jagielski nFldNum = 0;
3796*b1cdbd2cSJim Jagielski
3797*b1cdbd2cSJim Jagielski nLFOPosition = USHRT_MAX;
3798*b1cdbd2cSJim Jagielski nListLevel = WW8ListManager::nMaxLevel;
3799*b1cdbd2cSJim Jagielski eHardCharSet = RTL_TEXTENCODING_DONTKNOW;
3800*b1cdbd2cSJim Jagielski
3801*b1cdbd2cSJim Jagielski nPgChpDelim = nPgChpLevel = 0;
3802*b1cdbd2cSJim Jagielski
3803*b1cdbd2cSJim Jagielski maApos.push_back(false);
3804*b1cdbd2cSJim Jagielski }
3805*b1cdbd2cSJim Jagielski
DeleteStk(SwFltControlStack * pStck)3806*b1cdbd2cSJim Jagielski void SwWW8ImplReader::DeleteStk(SwFltControlStack* pStck)
3807*b1cdbd2cSJim Jagielski {
3808*b1cdbd2cSJim Jagielski if( pStck )
3809*b1cdbd2cSJim Jagielski {
3810*b1cdbd2cSJim Jagielski pStck->SetAttr( *pPaM->GetPoint(), 0, false);
3811*b1cdbd2cSJim Jagielski pStck->SetAttr( *pPaM->GetPoint(), 0, false);
3812*b1cdbd2cSJim Jagielski delete pStck;
3813*b1cdbd2cSJim Jagielski }
3814*b1cdbd2cSJim Jagielski else
3815*b1cdbd2cSJim Jagielski {
3816*b1cdbd2cSJim Jagielski ASSERT( !this, "WW-Stack bereits geloescht" );
3817*b1cdbd2cSJim Jagielski }
3818*b1cdbd2cSJim Jagielski }
3819*b1cdbd2cSJim Jagielski
SetSegmentToPageDesc(const wwSection & rSection,bool bTitlePage,bool bIgnoreCols)3820*b1cdbd2cSJim Jagielski void wwSectionManager::SetSegmentToPageDesc(const wwSection &rSection,
3821*b1cdbd2cSJim Jagielski bool bTitlePage, bool bIgnoreCols)
3822*b1cdbd2cSJim Jagielski {
3823*b1cdbd2cSJim Jagielski SwPageDesc &rPage = bTitlePage ? *rSection.mpTitlePage : *rSection.mpPage;
3824*b1cdbd2cSJim Jagielski
3825*b1cdbd2cSJim Jagielski SetNumberingType(rSection, rPage);
3826*b1cdbd2cSJim Jagielski
3827*b1cdbd2cSJim Jagielski SwFrmFmt &rFmt = rPage.GetMaster();
3828*b1cdbd2cSJim Jagielski
3829*b1cdbd2cSJim Jagielski if(mrReader.pWDop->fUseBackGroundInAllmodes) // #i56806# Make sure mrReader is initialized
3830*b1cdbd2cSJim Jagielski mrReader.GrafikCtor();
3831*b1cdbd2cSJim Jagielski
3832*b1cdbd2cSJim Jagielski
3833*b1cdbd2cSJim Jagielski if (mrReader.pWDop->fUseBackGroundInAllmodes && mrReader.pMSDffManager)
3834*b1cdbd2cSJim Jagielski {
3835*b1cdbd2cSJim Jagielski Rectangle aRect(0, 0, 100, 100); //A dummy, we don't care about the size
3836*b1cdbd2cSJim Jagielski SvxMSDffImportData aData(aRect);
3837*b1cdbd2cSJim Jagielski SdrObject* pObject = 0;
3838*b1cdbd2cSJim Jagielski if (mrReader.pMSDffManager->GetShape(0x401, pObject, aData))
3839*b1cdbd2cSJim Jagielski {
3840*b1cdbd2cSJim Jagielski SvxMSDffImportRec * pRec = aData.GetRecord(0);
3841*b1cdbd2cSJim Jagielski
3842*b1cdbd2cSJim Jagielski // Only handle shape if it is a background shape
3843*b1cdbd2cSJim Jagielski if ((pRec->nFlags & 0x400) != 0)
3844*b1cdbd2cSJim Jagielski {
3845*b1cdbd2cSJim Jagielski SfxItemSet aSet(rFmt.GetAttrSet());
3846*b1cdbd2cSJim Jagielski mrReader.MatchSdrItemsIntoFlySet(pObject, aSet, mso_lineSimple,
3847*b1cdbd2cSJim Jagielski mso_sptRectangle, aRect);
3848*b1cdbd2cSJim Jagielski rFmt.SetFmtAttr(aSet.Get(RES_BACKGROUND));
3849*b1cdbd2cSJim Jagielski }
3850*b1cdbd2cSJim Jagielski }
3851*b1cdbd2cSJim Jagielski }
3852*b1cdbd2cSJim Jagielski wwULSpaceData aULData;
3853*b1cdbd2cSJim Jagielski GetPageULData(rSection, bTitlePage, aULData);
3854*b1cdbd2cSJim Jagielski SetPageULSpaceItems(rFmt, aULData, rSection);
3855*b1cdbd2cSJim Jagielski
3856*b1cdbd2cSJim Jagielski SetPage(rPage, rFmt, rSection, bIgnoreCols);
3857*b1cdbd2cSJim Jagielski
3858*b1cdbd2cSJim Jagielski bool bSetBorder = false;
3859*b1cdbd2cSJim Jagielski switch (rSection.maSep.pgbApplyTo)
3860*b1cdbd2cSJim Jagielski {
3861*b1cdbd2cSJim Jagielski case 0:
3862*b1cdbd2cSJim Jagielski case 3:
3863*b1cdbd2cSJim Jagielski bSetBorder = true;
3864*b1cdbd2cSJim Jagielski break;
3865*b1cdbd2cSJim Jagielski case 1:
3866*b1cdbd2cSJim Jagielski bSetBorder = bTitlePage;
3867*b1cdbd2cSJim Jagielski break;
3868*b1cdbd2cSJim Jagielski case 2:
3869*b1cdbd2cSJim Jagielski bSetBorder = !bTitlePage;
3870*b1cdbd2cSJim Jagielski break;
3871*b1cdbd2cSJim Jagielski }
3872*b1cdbd2cSJim Jagielski if (bSetBorder)
3873*b1cdbd2cSJim Jagielski mrReader.SetPageBorder(rFmt, rSection);
3874*b1cdbd2cSJim Jagielski
3875*b1cdbd2cSJim Jagielski mrReader.SetDocumentGrid(rFmt, rSection);
3876*b1cdbd2cSJim Jagielski }
3877*b1cdbd2cSJim Jagielski
SetUseOn(wwSection & rSection)3878*b1cdbd2cSJim Jagielski void wwSectionManager::SetUseOn(wwSection &rSection)
3879*b1cdbd2cSJim Jagielski {
3880*b1cdbd2cSJim Jagielski bool bEven = (rSection.maSep.grpfIhdt & (WW8_HEADER_EVEN|WW8_FOOTER_EVEN)) ?
3881*b1cdbd2cSJim Jagielski true : false;
3882*b1cdbd2cSJim Jagielski
3883*b1cdbd2cSJim Jagielski bool bMirror = mrReader.pWDop->fMirrorMargins ||
3884*b1cdbd2cSJim Jagielski mrReader.pWDop->doptypography.f2on1;
3885*b1cdbd2cSJim Jagielski
3886*b1cdbd2cSJim Jagielski UseOnPage eUseBase = bMirror ? nsUseOnPage::PD_MIRROR : nsUseOnPage::PD_ALL;
3887*b1cdbd2cSJim Jagielski UseOnPage eUse = eUseBase;
3888*b1cdbd2cSJim Jagielski if (!bEven)
3889*b1cdbd2cSJim Jagielski eUse = (UseOnPage)(eUse | nsUseOnPage::PD_HEADERSHARE | nsUseOnPage::PD_FOOTERSHARE);
3890*b1cdbd2cSJim Jagielski
3891*b1cdbd2cSJim Jagielski ASSERT(rSection.mpPage, "Makes no sense to call me with no pages to set");
3892*b1cdbd2cSJim Jagielski if (rSection.mpPage)
3893*b1cdbd2cSJim Jagielski rSection.mpPage->WriteUseOn(eUse);
3894*b1cdbd2cSJim Jagielski if (rSection.mpTitlePage)
3895*b1cdbd2cSJim Jagielski {
3896*b1cdbd2cSJim Jagielski rSection.mpTitlePage->WriteUseOn(
3897*b1cdbd2cSJim Jagielski (UseOnPage) (eUseBase | nsUseOnPage::PD_HEADERSHARE | nsUseOnPage::PD_FOOTERSHARE));
3898*b1cdbd2cSJim Jagielski }
3899*b1cdbd2cSJim Jagielski }
3900*b1cdbd2cSJim Jagielski
3901*b1cdbd2cSJim Jagielski //Set the page descriptor on this node, handle the different cases for a text
3902*b1cdbd2cSJim Jagielski //node or a table
GiveNodePageDesc(SwNodeIndex & rIdx,const SwFmtPageDesc & rPgDesc,SwDoc & rDoc)3903*b1cdbd2cSJim Jagielski void GiveNodePageDesc(SwNodeIndex &rIdx, const SwFmtPageDesc &rPgDesc,
3904*b1cdbd2cSJim Jagielski SwDoc &rDoc)
3905*b1cdbd2cSJim Jagielski {
3906*b1cdbd2cSJim Jagielski /*
3907*b1cdbd2cSJim Jagielski If its a table here, apply the pagebreak to the table
3908*b1cdbd2cSJim Jagielski properties, otherwise we add it to the para at this
3909*b1cdbd2cSJim Jagielski position
3910*b1cdbd2cSJim Jagielski */
3911*b1cdbd2cSJim Jagielski if (rIdx.GetNode().IsTableNode())
3912*b1cdbd2cSJim Jagielski {
3913*b1cdbd2cSJim Jagielski SwTable& rTable =
3914*b1cdbd2cSJim Jagielski rIdx.GetNode().GetTableNode()->GetTable();
3915*b1cdbd2cSJim Jagielski SwFrmFmt* pApply = rTable.GetFrmFmt();
3916*b1cdbd2cSJim Jagielski ASSERT(pApply, "impossible");
3917*b1cdbd2cSJim Jagielski if (pApply)
3918*b1cdbd2cSJim Jagielski pApply->SetFmtAttr(rPgDesc);
3919*b1cdbd2cSJim Jagielski }
3920*b1cdbd2cSJim Jagielski else
3921*b1cdbd2cSJim Jagielski {
3922*b1cdbd2cSJim Jagielski SwPosition aPamStart(rIdx);
3923*b1cdbd2cSJim Jagielski aPamStart.nContent.Assign(
3924*b1cdbd2cSJim Jagielski rIdx.GetNode().GetCntntNode(), 0);
3925*b1cdbd2cSJim Jagielski SwPaM aPage(aPamStart);
3926*b1cdbd2cSJim Jagielski
3927*b1cdbd2cSJim Jagielski rDoc.InsertPoolItem(aPage, rPgDesc, 0);
3928*b1cdbd2cSJim Jagielski }
3929*b1cdbd2cSJim Jagielski }
3930*b1cdbd2cSJim Jagielski
3931*b1cdbd2cSJim Jagielski //Map a word section with to either one or two writer page descriptors
3932*b1cdbd2cSJim Jagielski //depending on if the word section has a title page
SetSwFmtPageDesc(mySegIter & rIter,mySegIter & rStart,bool bIgnoreCols)3933*b1cdbd2cSJim Jagielski SwFmtPageDesc wwSectionManager::SetSwFmtPageDesc(mySegIter &rIter,
3934*b1cdbd2cSJim Jagielski mySegIter &rStart, bool bIgnoreCols)
3935*b1cdbd2cSJim Jagielski {
3936*b1cdbd2cSJim Jagielski SwFmtPageDesc aEmpty;
3937*b1cdbd2cSJim Jagielski // Always read title page header/footer data - it could be used by following sections
3938*b1cdbd2cSJim Jagielski {
3939*b1cdbd2cSJim Jagielski if (IsNewDoc() && rIter == rStart)
3940*b1cdbd2cSJim Jagielski {
3941*b1cdbd2cSJim Jagielski rIter->mpTitlePage =
3942*b1cdbd2cSJim Jagielski mrReader.rDoc.GetPageDescFromPool(RES_POOLPAGE_FIRST);
3943*b1cdbd2cSJim Jagielski }
3944*b1cdbd2cSJim Jagielski else
3945*b1cdbd2cSJim Jagielski {
3946*b1cdbd2cSJim Jagielski sal_uInt16 nPos = mrReader.rDoc.MakePageDesc(
3947*b1cdbd2cSJim Jagielski ViewShell::GetShellRes()->GetPageDescName(mnDesc)
3948*b1cdbd2cSJim Jagielski , 0, false);
3949*b1cdbd2cSJim Jagielski rIter->mpTitlePage = &mrReader.rDoc._GetPageDesc(nPos);
3950*b1cdbd2cSJim Jagielski }
3951*b1cdbd2cSJim Jagielski ASSERT(rIter->mpTitlePage, "no page!");
3952*b1cdbd2cSJim Jagielski if (!rIter->mpTitlePage)
3953*b1cdbd2cSJim Jagielski return aEmpty;
3954*b1cdbd2cSJim Jagielski
3955*b1cdbd2cSJim Jagielski SetSegmentToPageDesc(*rIter, true, bIgnoreCols);
3956*b1cdbd2cSJim Jagielski }
3957*b1cdbd2cSJim Jagielski
3958*b1cdbd2cSJim Jagielski if (IsNewDoc() && rIter == rStart)
3959*b1cdbd2cSJim Jagielski {
3960*b1cdbd2cSJim Jagielski rIter->mpPage =
3961*b1cdbd2cSJim Jagielski mrReader.rDoc.GetPageDescFromPool(RES_POOLPAGE_STANDARD);
3962*b1cdbd2cSJim Jagielski }
3963*b1cdbd2cSJim Jagielski else
3964*b1cdbd2cSJim Jagielski {
3965*b1cdbd2cSJim Jagielski sal_uInt16 nPos = mrReader.rDoc.MakePageDesc(
3966*b1cdbd2cSJim Jagielski ViewShell::GetShellRes()->GetPageDescName(mnDesc,
3967*b1cdbd2cSJim Jagielski false, rIter->HasTitlePage()),
3968*b1cdbd2cSJim Jagielski rIter->mpTitlePage, false);
3969*b1cdbd2cSJim Jagielski rIter->mpPage = &mrReader.rDoc._GetPageDesc(nPos);
3970*b1cdbd2cSJim Jagielski }
3971*b1cdbd2cSJim Jagielski ASSERT(rIter->mpPage, "no page!");
3972*b1cdbd2cSJim Jagielski if (!rIter->mpPage)
3973*b1cdbd2cSJim Jagielski return aEmpty;
3974*b1cdbd2cSJim Jagielski
3975*b1cdbd2cSJim Jagielski //Set page before hd/ft
3976*b1cdbd2cSJim Jagielski const wwSection *pPrevious = 0;
3977*b1cdbd2cSJim Jagielski
3978*b1cdbd2cSJim Jagielski mySegIter aPrev = rIter;
3979*b1cdbd2cSJim Jagielski while( aPrev!= rStart )
3980*b1cdbd2cSJim Jagielski {
3981*b1cdbd2cSJim Jagielski aPrev--;
3982*b1cdbd2cSJim Jagielski pPrevious = &(*(aPrev));
3983*b1cdbd2cSJim Jagielski if( aPrev->IsContinous())
3984*b1cdbd2cSJim Jagielski continue;
3985*b1cdbd2cSJim Jagielski else{
3986*b1cdbd2cSJim Jagielski break;
3987*b1cdbd2cSJim Jagielski }
3988*b1cdbd2cSJim Jagielski }
3989*b1cdbd2cSJim Jagielski
3990*b1cdbd2cSJim Jagielski SetHdFt(*rIter, std::distance(rStart, rIter), pPrevious);
3991*b1cdbd2cSJim Jagielski SetUseOn(*rIter);
3992*b1cdbd2cSJim Jagielski
3993*b1cdbd2cSJim Jagielski //Set hd/ft after set page
3994*b1cdbd2cSJim Jagielski if (rIter->mpTitlePage)
3995*b1cdbd2cSJim Jagielski SetSegmentToPageDesc(*rIter, true, bIgnoreCols);
3996*b1cdbd2cSJim Jagielski SetSegmentToPageDesc(*rIter, false, bIgnoreCols);
3997*b1cdbd2cSJim Jagielski
3998*b1cdbd2cSJim Jagielski SwFmtPageDesc aRet(rIter->HasTitlePage() ?
3999*b1cdbd2cSJim Jagielski rIter->mpTitlePage : rIter->mpPage);
4000*b1cdbd2cSJim Jagielski
4001*b1cdbd2cSJim Jagielski rIter->mpPage->SetFollow(rIter->mpPage);
4002*b1cdbd2cSJim Jagielski
4003*b1cdbd2cSJim Jagielski if (rIter->mpTitlePage)
4004*b1cdbd2cSJim Jagielski rIter->mpTitlePage->SetFollow(rIter->mpPage);
4005*b1cdbd2cSJim Jagielski
4006*b1cdbd2cSJim Jagielski if (rIter->PageRestartNo())
4007*b1cdbd2cSJim Jagielski aRet.SetNumOffset(rIter->PageStartAt());
4008*b1cdbd2cSJim Jagielski
4009*b1cdbd2cSJim Jagielski ++mnDesc;
4010*b1cdbd2cSJim Jagielski return aRet;
4011*b1cdbd2cSJim Jagielski }
4012*b1cdbd2cSJim Jagielski
IsNewDoc() const4013*b1cdbd2cSJim Jagielski bool wwSectionManager::IsNewDoc() const
4014*b1cdbd2cSJim Jagielski {
4015*b1cdbd2cSJim Jagielski return mrReader.mbNewDoc;
4016*b1cdbd2cSJim Jagielski }
4017*b1cdbd2cSJim Jagielski
InsertSegments()4018*b1cdbd2cSJim Jagielski void wwSectionManager::InsertSegments()
4019*b1cdbd2cSJim Jagielski {
4020*b1cdbd2cSJim Jagielski const SvtFilterOptions* pOpt = SvtFilterOptions::Get();
4021*b1cdbd2cSJim Jagielski sal_Bool bUseEnhFields=(pOpt && pOpt->IsUseEnhancedFields());
4022*b1cdbd2cSJim Jagielski mySegIter aEnd = maSegments.end();
4023*b1cdbd2cSJim Jagielski mySegIter aStart = maSegments.begin();
4024*b1cdbd2cSJim Jagielski for (mySegIter aIter = aStart; aIter != aEnd; ++aIter)
4025*b1cdbd2cSJim Jagielski {
4026*b1cdbd2cSJim Jagielski mySegIter aNext = aIter+1;
4027*b1cdbd2cSJim Jagielski mySegIter aPrev = (aIter == aStart) ? aIter : aIter-1;
4028*b1cdbd2cSJim Jagielski
4029*b1cdbd2cSJim Jagielski // If two following sections are different in following properties, Word will interprete a continuous
4030*b1cdbd2cSJim Jagielski // section break between them as if it was a section break next page.
4031*b1cdbd2cSJim Jagielski bool bThisAndPreviousAreCompatible = ((aIter->GetPageWidth() == aPrev->GetPageWidth()) &&
4032*b1cdbd2cSJim Jagielski (aIter->GetPageHeight() == aPrev->GetPageHeight()) && (aIter->IsLandScape() == aPrev->IsLandScape()));
4033*b1cdbd2cSJim Jagielski
4034*b1cdbd2cSJim Jagielski bool bInsertSection = (aIter != aStart) ? (aIter->IsContinous() && bThisAndPreviousAreCompatible): false;
4035*b1cdbd2cSJim Jagielski bool bInsertPageDesc = !bInsertSection;
4036*b1cdbd2cSJim Jagielski bool bProtected = SectionIsProtected(*aIter); // do we really need this ?? I guess I have a different logic in editshell which disales this...
4037*b1cdbd2cSJim Jagielski if (bUseEnhFields && mrReader.pWDop->fProtEnabled && aIter->IsNotProtected())
4038*b1cdbd2cSJim Jagielski {
4039*b1cdbd2cSJim Jagielski // here we have the special case that the whole document is protected, with the execption of this section.
4040*b1cdbd2cSJim Jagielski // I want to address this when I do the section rework, so for the moment we disable the overall protection then...
4041*b1cdbd2cSJim Jagielski mrReader.rDoc.set(IDocumentSettingAccess::PROTECT_FORM, false );
4042*b1cdbd2cSJim Jagielski }
4043*b1cdbd2cSJim Jagielski
4044*b1cdbd2cSJim Jagielski
4045*b1cdbd2cSJim Jagielski if (bInsertPageDesc)
4046*b1cdbd2cSJim Jagielski {
4047*b1cdbd2cSJim Jagielski /*
4048*b1cdbd2cSJim Jagielski If a cont section follows this section then we won't be
4049*b1cdbd2cSJim Jagielski creating a page desc with 2+ cols as we cannot host a one
4050*b1cdbd2cSJim Jagielski col section in a 2+ col pagedesc and make it look like
4051*b1cdbd2cSJim Jagielski word. But if the current section actually has columns then
4052*b1cdbd2cSJim Jagielski we are forced to insert a section here as well as a page
4053*b1cdbd2cSJim Jagielski descriptor.
4054*b1cdbd2cSJim Jagielski */
4055*b1cdbd2cSJim Jagielski
4056*b1cdbd2cSJim Jagielski bool bIgnoreCols = false;
4057*b1cdbd2cSJim Jagielski bool bThisAndNextAreCompatible = (aNext != aEnd) ? ((aIter->GetPageWidth() == aNext->GetPageWidth()) &&
4058*b1cdbd2cSJim Jagielski (aIter->GetPageHeight() == aNext->GetPageHeight()) && (aIter->IsLandScape() == aNext->IsLandScape())) : true;
4059*b1cdbd2cSJim Jagielski
4060*b1cdbd2cSJim Jagielski if (((aNext != aEnd && aNext->IsContinous() && bThisAndNextAreCompatible) || bProtected))
4061*b1cdbd2cSJim Jagielski {
4062*b1cdbd2cSJim Jagielski bIgnoreCols = true;
4063*b1cdbd2cSJim Jagielski if ((aIter->NoCols() > 1) || bProtected)
4064*b1cdbd2cSJim Jagielski bInsertSection = true;
4065*b1cdbd2cSJim Jagielski }
4066*b1cdbd2cSJim Jagielski
4067*b1cdbd2cSJim Jagielski SwFmtPageDesc aDesc(SetSwFmtPageDesc(aIter, aStart, bIgnoreCols));
4068*b1cdbd2cSJim Jagielski if (!aDesc.GetPageDesc())
4069*b1cdbd2cSJim Jagielski continue;
4070*b1cdbd2cSJim Jagielski GiveNodePageDesc(aIter->maStart, aDesc, mrReader.rDoc);
4071*b1cdbd2cSJim Jagielski }
4072*b1cdbd2cSJim Jagielski
4073*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = 0;
4074*b1cdbd2cSJim Jagielski if (bInsertSection)
4075*b1cdbd2cSJim Jagielski {
4076*b1cdbd2cSJim Jagielski //Start getting the bounds of this section
4077*b1cdbd2cSJim Jagielski SwPaM aSectPaM(*mrReader.pPaM);
4078*b1cdbd2cSJim Jagielski SwNodeIndex aAnchor(aSectPaM.GetPoint()->nNode);
4079*b1cdbd2cSJim Jagielski if (aNext != aEnd)
4080*b1cdbd2cSJim Jagielski {
4081*b1cdbd2cSJim Jagielski aAnchor = aNext->maStart;
4082*b1cdbd2cSJim Jagielski aSectPaM.GetPoint()->nNode = aAnchor;
4083*b1cdbd2cSJim Jagielski aSectPaM.GetPoint()->nContent.Assign(
4084*b1cdbd2cSJim Jagielski aNext->maStart.GetNode().GetCntntNode(), 0);
4085*b1cdbd2cSJim Jagielski aSectPaM.Move(fnMoveBackward);
4086*b1cdbd2cSJim Jagielski }
4087*b1cdbd2cSJim Jagielski
4088*b1cdbd2cSJim Jagielski const SwPosition* pPos = aSectPaM.GetPoint();
4089*b1cdbd2cSJim Jagielski SwTxtNode const*const pSttNd = pPos->nNode.GetNode().GetTxtNode();
4090*b1cdbd2cSJim Jagielski const SwTableNode* pTableNd = pSttNd ? pSttNd->FindTableNode() : 0;
4091*b1cdbd2cSJim Jagielski if (pTableNd)
4092*b1cdbd2cSJim Jagielski {
4093*b1cdbd2cSJim Jagielski pTxtNd =
4094*b1cdbd2cSJim Jagielski mrReader.rDoc.GetNodes().MakeTxtNode(aAnchor,
4095*b1cdbd2cSJim Jagielski mrReader.rDoc.GetTxtCollFromPool( RES_POOLCOLL_TEXT ));
4096*b1cdbd2cSJim Jagielski
4097*b1cdbd2cSJim Jagielski aSectPaM.GetPoint()->nNode = SwNodeIndex(*pTxtNd);
4098*b1cdbd2cSJim Jagielski aSectPaM.GetPoint()->nContent.Assign(
4099*b1cdbd2cSJim Jagielski aSectPaM.GetCntntNode(), 0);
4100*b1cdbd2cSJim Jagielski }
4101*b1cdbd2cSJim Jagielski
4102*b1cdbd2cSJim Jagielski aSectPaM.SetMark();
4103*b1cdbd2cSJim Jagielski
4104*b1cdbd2cSJim Jagielski aSectPaM.GetPoint()->nNode = aIter->maStart;
4105*b1cdbd2cSJim Jagielski aSectPaM.GetPoint()->nContent.Assign(
4106*b1cdbd2cSJim Jagielski aSectPaM.GetCntntNode(), 0);
4107*b1cdbd2cSJim Jagielski //End getting the bounds of this section, quite a job eh ?
4108*b1cdbd2cSJim Jagielski
4109*b1cdbd2cSJim Jagielski SwSectionFmt *pRet = InsertSection(aSectPaM, *aIter);
4110*b1cdbd2cSJim Jagielski //The last section if continous is always unbalanced
4111*b1cdbd2cSJim Jagielski if (pRet)
4112*b1cdbd2cSJim Jagielski {
4113*b1cdbd2cSJim Jagielski //Set the columns to be UnBalanced if that compatability option
4114*b1cdbd2cSJim Jagielski //is set
4115*b1cdbd2cSJim Jagielski if (mrReader.pWDop->fNoColumnBalance)
4116*b1cdbd2cSJim Jagielski pRet->SetFmtAttr(SwFmtNoBalancedColumns(true));
4117*b1cdbd2cSJim Jagielski else
4118*b1cdbd2cSJim Jagielski {
4119*b1cdbd2cSJim Jagielski //Otherwise set to unbalanced if the following section is
4120*b1cdbd2cSJim Jagielski //not continuous, (which also means that the last section
4121*b1cdbd2cSJim Jagielski //is unbalanced)
4122*b1cdbd2cSJim Jagielski if (aNext == aEnd || !aNext->IsContinous())
4123*b1cdbd2cSJim Jagielski pRet->SetFmtAttr(SwFmtNoBalancedColumns(true));
4124*b1cdbd2cSJim Jagielski }
4125*b1cdbd2cSJim Jagielski }
4126*b1cdbd2cSJim Jagielski
4127*b1cdbd2cSJim Jagielski bool bHasOwnHdFt = false;
4128*b1cdbd2cSJim Jagielski /*
4129*b1cdbd2cSJim Jagielski In this nightmare scenario the continuous section has its own
4130*b1cdbd2cSJim Jagielski headers and footers so we will try and find a hard page break
4131*b1cdbd2cSJim Jagielski between here and the end of the section and put the headers and
4132*b1cdbd2cSJim Jagielski footers there.
4133*b1cdbd2cSJim Jagielski */
4134*b1cdbd2cSJim Jagielski if (!bInsertPageDesc)
4135*b1cdbd2cSJim Jagielski {
4136*b1cdbd2cSJim Jagielski bHasOwnHdFt =
4137*b1cdbd2cSJim Jagielski mrReader.HasOwnHeaderFooter(
4138*b1cdbd2cSJim Jagielski aIter->maSep.grpfIhdt & ~(WW8_HEADER_FIRST | WW8_FOOTER_FIRST),
4139*b1cdbd2cSJim Jagielski aIter->maSep.grpfIhdt, std::distance(aStart, aIter)
4140*b1cdbd2cSJim Jagielski );
4141*b1cdbd2cSJim Jagielski }
4142*b1cdbd2cSJim Jagielski if (bHasOwnHdFt)
4143*b1cdbd2cSJim Jagielski {
4144*b1cdbd2cSJim Jagielski // #i40766# Need to cache the page descriptor in case there is
4145*b1cdbd2cSJim Jagielski // no page break in the section
4146*b1cdbd2cSJim Jagielski SwPageDesc *pOrig = aIter->mpPage;
4147*b1cdbd2cSJim Jagielski SwPageDesc *pOrigTitle = aIter->mpTitlePage;
4148*b1cdbd2cSJim Jagielski bool bFailed = true;
4149*b1cdbd2cSJim Jagielski SwFmtPageDesc aDesc(SetSwFmtPageDesc(aIter, aStart, true));
4150*b1cdbd2cSJim Jagielski if (aDesc.GetPageDesc())
4151*b1cdbd2cSJim Jagielski {
4152*b1cdbd2cSJim Jagielski sal_uLong nStart = aSectPaM.Start()->nNode.GetIndex();
4153*b1cdbd2cSJim Jagielski sal_uLong nEnd = aSectPaM.End()->nNode.GetIndex();
4154*b1cdbd2cSJim Jagielski for(; nStart <= nEnd; ++nStart)
4155*b1cdbd2cSJim Jagielski {
4156*b1cdbd2cSJim Jagielski SwNode* pNode = mrReader.rDoc.GetNodes()[nStart];
4157*b1cdbd2cSJim Jagielski if (!pNode)
4158*b1cdbd2cSJim Jagielski continue;
4159*b1cdbd2cSJim Jagielski if (sw::util::HasPageBreak(*pNode))
4160*b1cdbd2cSJim Jagielski {
4161*b1cdbd2cSJim Jagielski SwNodeIndex aIdx(*pNode);
4162*b1cdbd2cSJim Jagielski GiveNodePageDesc(aIdx, aDesc, mrReader.rDoc);
4163*b1cdbd2cSJim Jagielski bFailed = false;
4164*b1cdbd2cSJim Jagielski break;
4165*b1cdbd2cSJim Jagielski }
4166*b1cdbd2cSJim Jagielski }
4167*b1cdbd2cSJim Jagielski }
4168*b1cdbd2cSJim Jagielski if(bFailed)
4169*b1cdbd2cSJim Jagielski {
4170*b1cdbd2cSJim Jagielski aIter->mpPage = pOrig;
4171*b1cdbd2cSJim Jagielski aIter->mpTitlePage = pOrigTitle;
4172*b1cdbd2cSJim Jagielski }
4173*b1cdbd2cSJim Jagielski }
4174*b1cdbd2cSJim Jagielski }
4175*b1cdbd2cSJim Jagielski
4176*b1cdbd2cSJim Jagielski if (pTxtNd)
4177*b1cdbd2cSJim Jagielski {
4178*b1cdbd2cSJim Jagielski SwNodeIndex aIdx(*pTxtNd);
4179*b1cdbd2cSJim Jagielski SwPosition aPos(aIdx);
4180*b1cdbd2cSJim Jagielski SwPaM aTest(aPos);
4181*b1cdbd2cSJim Jagielski mrReader.rDoc.DelFullPara(aTest);
4182*b1cdbd2cSJim Jagielski pTxtNd = 0;
4183*b1cdbd2cSJim Jagielski }
4184*b1cdbd2cSJim Jagielski }
4185*b1cdbd2cSJim Jagielski }
4186*b1cdbd2cSJim Jagielski
StoreMacroCmds()4187*b1cdbd2cSJim Jagielski void SwWW8ImplReader::StoreMacroCmds()
4188*b1cdbd2cSJim Jagielski {
4189*b1cdbd2cSJim Jagielski if (pWwFib->lcbCmds)
4190*b1cdbd2cSJim Jagielski {
4191*b1cdbd2cSJim Jagielski maTracer.Log(sw::log::eContainsWordBasic);
4192*b1cdbd2cSJim Jagielski
4193*b1cdbd2cSJim Jagielski pTableStream->Seek(pWwFib->fcCmds);
4194*b1cdbd2cSJim Jagielski
4195*b1cdbd2cSJim Jagielski uno::Reference < embed::XStorage > xRoot(mpDocShell->GetStorage());
4196*b1cdbd2cSJim Jagielski try
4197*b1cdbd2cSJim Jagielski {
4198*b1cdbd2cSJim Jagielski uno::Reference < io::XStream > xStream =
4199*b1cdbd2cSJim Jagielski xRoot->openStreamElement( CREATE_CONST_ASC(SL::aMSMacroCmds), embed::ElementModes::READWRITE );
4200*b1cdbd2cSJim Jagielski SvStream* pStream = ::utl::UcbStreamHelper::CreateStream( xStream );
4201*b1cdbd2cSJim Jagielski
4202*b1cdbd2cSJim Jagielski sal_uInt8 *pBuffer = new sal_uInt8[pWwFib->lcbCmds];
4203*b1cdbd2cSJim Jagielski pTableStream->Read(pBuffer, pWwFib->lcbCmds);
4204*b1cdbd2cSJim Jagielski pStream->Write(pBuffer, pWwFib->lcbCmds);
4205*b1cdbd2cSJim Jagielski delete[] pBuffer;
4206*b1cdbd2cSJim Jagielski delete pStream;
4207*b1cdbd2cSJim Jagielski }
4208*b1cdbd2cSJim Jagielski catch ( uno::Exception& )
4209*b1cdbd2cSJim Jagielski {
4210*b1cdbd2cSJim Jagielski }
4211*b1cdbd2cSJim Jagielski }
4212*b1cdbd2cSJim Jagielski }
4213*b1cdbd2cSJim Jagielski
ReadDocVars()4214*b1cdbd2cSJim Jagielski void SwWW8ImplReader::ReadDocVars()
4215*b1cdbd2cSJim Jagielski {
4216*b1cdbd2cSJim Jagielski std::vector<String> aDocVarStrings;
4217*b1cdbd2cSJim Jagielski std::vector<ww::bytes> aDocVarStringIds;
4218*b1cdbd2cSJim Jagielski std::vector<String> aDocValueStrings;
4219*b1cdbd2cSJim Jagielski WW8ReadSTTBF(!bVer67, *pTableStream, pWwFib->fcStwUser,
4220*b1cdbd2cSJim Jagielski pWwFib->lcbStwUser, bVer67 ? 2 : 0, eStructCharSet,
4221*b1cdbd2cSJim Jagielski aDocVarStrings, &aDocVarStringIds, &aDocValueStrings);
4222*b1cdbd2cSJim Jagielski if (!bVer67) {
4223*b1cdbd2cSJim Jagielski using namespace ::com::sun::star;
4224*b1cdbd2cSJim Jagielski
4225*b1cdbd2cSJim Jagielski uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
4226*b1cdbd2cSJim Jagielski mpDocShell->GetModel(), uno::UNO_QUERY_THROW);
4227*b1cdbd2cSJim Jagielski uno::Reference<document::XDocumentProperties> xDocProps(
4228*b1cdbd2cSJim Jagielski xDPS->getDocumentProperties());
4229*b1cdbd2cSJim Jagielski DBG_ASSERT(xDocProps.is(), "DocumentProperties is null");
4230*b1cdbd2cSJim Jagielski uno::Reference<beans::XPropertyContainer> xUserDefinedProps =
4231*b1cdbd2cSJim Jagielski xDocProps->getUserDefinedProperties();
4232*b1cdbd2cSJim Jagielski DBG_ASSERT(xUserDefinedProps.is(), "UserDefinedProperties is null");
4233*b1cdbd2cSJim Jagielski
4234*b1cdbd2cSJim Jagielski for(size_t i=0; i<aDocVarStrings.size(); i++)
4235*b1cdbd2cSJim Jagielski {
4236*b1cdbd2cSJim Jagielski uno::Any aDefaultValue;
4237*b1cdbd2cSJim Jagielski ::rtl::OUString name(aDocVarStrings[i]);
4238*b1cdbd2cSJim Jagielski uno::Any aValue;
4239*b1cdbd2cSJim Jagielski aValue <<= ::rtl::OUString(aDocValueStrings[i]);
4240*b1cdbd2cSJim Jagielski try {
4241*b1cdbd2cSJim Jagielski xUserDefinedProps->addProperty( name,
4242*b1cdbd2cSJim Jagielski beans::PropertyAttribute::REMOVEABLE,
4243*b1cdbd2cSJim Jagielski aValue );
4244*b1cdbd2cSJim Jagielski } catch (uno::Exception &) {
4245*b1cdbd2cSJim Jagielski // ignore
4246*b1cdbd2cSJim Jagielski }
4247*b1cdbd2cSJim Jagielski }
4248*b1cdbd2cSJim Jagielski }
4249*b1cdbd2cSJim Jagielski }
4250*b1cdbd2cSJim Jagielski
4251*b1cdbd2cSJim Jagielski //-----------------------------------------
4252*b1cdbd2cSJim Jagielski // Document Info
4253*b1cdbd2cSJim Jagielski //-----------------------------------------
4254*b1cdbd2cSJim Jagielski
ReadDocInfo()4255*b1cdbd2cSJim Jagielski void SwWW8ImplReader::ReadDocInfo()
4256*b1cdbd2cSJim Jagielski {
4257*b1cdbd2cSJim Jagielski if( pStg )
4258*b1cdbd2cSJim Jagielski {
4259*b1cdbd2cSJim Jagielski uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
4260*b1cdbd2cSJim Jagielski mpDocShell->GetModel(), uno::UNO_QUERY_THROW);
4261*b1cdbd2cSJim Jagielski uno::Reference<document::XDocumentProperties> xDocProps(
4262*b1cdbd2cSJim Jagielski xDPS->getDocumentProperties());
4263*b1cdbd2cSJim Jagielski DBG_ASSERT(xDocProps.is(), "DocumentProperties is null");
4264*b1cdbd2cSJim Jagielski
4265*b1cdbd2cSJim Jagielski if (xDocProps.is()) {
4266*b1cdbd2cSJim Jagielski sfx2::LoadOlePropertySet(xDocProps, pStg);
4267*b1cdbd2cSJim Jagielski }
4268*b1cdbd2cSJim Jagielski }
4269*b1cdbd2cSJim Jagielski }
4270*b1cdbd2cSJim Jagielski
CoreLoad(WW8Glossary * pGloss,const SwPosition & rPos)4271*b1cdbd2cSJim Jagielski sal_uLong SwWW8ImplReader::CoreLoad(WW8Glossary *pGloss, const SwPosition &rPos)
4272*b1cdbd2cSJim Jagielski {
4273*b1cdbd2cSJim Jagielski sal_uLong nErrRet = 0;
4274*b1cdbd2cSJim Jagielski
4275*b1cdbd2cSJim Jagielski rDoc.SetDocumentType( SwDoc::DOCTYPE_MSWORD );
4276*b1cdbd2cSJim Jagielski if (mbNewDoc && pStg && !pGloss)
4277*b1cdbd2cSJim Jagielski ReadDocInfo();
4278*b1cdbd2cSJim Jagielski
4279*b1cdbd2cSJim Jagielski ::ww8::WW8FibData * pFibData = new ::ww8::WW8FibData();
4280*b1cdbd2cSJim Jagielski
4281*b1cdbd2cSJim Jagielski if (pWwFib->fReadOnlyRecommended)
4282*b1cdbd2cSJim Jagielski pFibData->setReadOnlyRecommended(true);
4283*b1cdbd2cSJim Jagielski else
4284*b1cdbd2cSJim Jagielski pFibData->setReadOnlyRecommended(false);
4285*b1cdbd2cSJim Jagielski
4286*b1cdbd2cSJim Jagielski if (pWwFib->fWriteReservation)
4287*b1cdbd2cSJim Jagielski pFibData->setWriteReservation(true);
4288*b1cdbd2cSJim Jagielski else
4289*b1cdbd2cSJim Jagielski pFibData->setWriteReservation(false);
4290*b1cdbd2cSJim Jagielski
4291*b1cdbd2cSJim Jagielski ::sw::tExternalDataPointer pExternalFibData(pFibData);
4292*b1cdbd2cSJim Jagielski
4293*b1cdbd2cSJim Jagielski rDoc.setExternalData(::sw::FIB, pExternalFibData);
4294*b1cdbd2cSJim Jagielski
4295*b1cdbd2cSJim Jagielski ::sw::tExternalDataPointer pSttbfAsoc
4296*b1cdbd2cSJim Jagielski (new ::ww8::WW8Sttb<ww8::WW8Struct>(*pTableStream, pWwFib->fcSttbfAssoc, pWwFib->lcbSttbfAssoc));
4297*b1cdbd2cSJim Jagielski
4298*b1cdbd2cSJim Jagielski rDoc.setExternalData(::sw::STTBF_ASSOC, pSttbfAsoc);
4299*b1cdbd2cSJim Jagielski
4300*b1cdbd2cSJim Jagielski if (pWwFib->fWriteReservation || pWwFib->fReadOnlyRecommended)
4301*b1cdbd2cSJim Jagielski {
4302*b1cdbd2cSJim Jagielski SwDocShell * pDocShell = rDoc.GetDocShell();
4303*b1cdbd2cSJim Jagielski if (pDocShell)
4304*b1cdbd2cSJim Jagielski pDocShell->SetReadOnlyUI(sal_True);
4305*b1cdbd2cSJim Jagielski }
4306*b1cdbd2cSJim Jagielski
4307*b1cdbd2cSJim Jagielski pPaM = new SwPaM(rPos);
4308*b1cdbd2cSJim Jagielski
4309*b1cdbd2cSJim Jagielski pCtrlStck = new SwWW8FltControlStack( &rDoc, nFieldFlags, *this );
4310*b1cdbd2cSJim Jagielski
4311*b1cdbd2cSJim Jagielski mpRedlineStack = new sw::util::RedlineStack(rDoc);
4312*b1cdbd2cSJim Jagielski
4313*b1cdbd2cSJim Jagielski /*
4314*b1cdbd2cSJim Jagielski RefFldStck: Keeps track of bookmarks which may be inserted as
4315*b1cdbd2cSJim Jagielski variables intstead.
4316*b1cdbd2cSJim Jagielski */
4317*b1cdbd2cSJim Jagielski pReffedStck = new SwWW8ReferencedFltEndStack(&rDoc, nFieldFlags);
4318*b1cdbd2cSJim Jagielski pReffingStck = new SwWW8FltRefStack(&rDoc, nFieldFlags);
4319*b1cdbd2cSJim Jagielski
4320*b1cdbd2cSJim Jagielski pAnchorStck = new SwWW8FltAnchorStack(&rDoc, nFieldFlags);
4321*b1cdbd2cSJim Jagielski
4322*b1cdbd2cSJim Jagielski sal_uInt16 nPageDescOffset = rDoc.GetPageDescCnt();
4323*b1cdbd2cSJim Jagielski
4324*b1cdbd2cSJim Jagielski SwNodeIndex aSttNdIdx( rDoc.GetNodes() );
4325*b1cdbd2cSJim Jagielski SwRelNumRuleSpaces aRelNumRule(rDoc, mbNewDoc);
4326*b1cdbd2cSJim Jagielski
4327*b1cdbd2cSJim Jagielski sal_uInt16 eMode = nsRedlineMode_t::REDLINE_SHOW_INSERT;
4328*b1cdbd2cSJim Jagielski
4329*b1cdbd2cSJim Jagielski mpSprmParser = new wwSprmParser(pWwFib->GetFIBVersion());
4330*b1cdbd2cSJim Jagielski
4331*b1cdbd2cSJim Jagielski // praktische Hilfsvariablen besetzen:
4332*b1cdbd2cSJim Jagielski bVer6 = (6 == pWwFib->nVersion);
4333*b1cdbd2cSJim Jagielski bVer7 = (7 == pWwFib->nVersion);
4334*b1cdbd2cSJim Jagielski bVer67 = bVer6 || bVer7;
4335*b1cdbd2cSJim Jagielski bVer8 = (8 == pWwFib->nVersion);
4336*b1cdbd2cSJim Jagielski
4337*b1cdbd2cSJim Jagielski eTextCharSet = WW8Fib::GetFIBCharset(pWwFib->chse);
4338*b1cdbd2cSJim Jagielski eStructCharSet = WW8Fib::GetFIBCharset(pWwFib->chseTables);
4339*b1cdbd2cSJim Jagielski
4340*b1cdbd2cSJim Jagielski bWWBugNormal = pWwFib->nProduct == 0xc03d;
4341*b1cdbd2cSJim Jagielski
4342*b1cdbd2cSJim Jagielski if (!mbNewDoc)
4343*b1cdbd2cSJim Jagielski aSttNdIdx = pPaM->GetPoint()->nNode;
4344*b1cdbd2cSJim Jagielski
4345*b1cdbd2cSJim Jagielski ::StartProgress(STR_STATSTR_W4WREAD, 0, 100, mpDocShell);
4346*b1cdbd2cSJim Jagielski
4347*b1cdbd2cSJim Jagielski #ifdef DEBUGDUMP
4348*b1cdbd2cSJim Jagielski //experimental embedded ttf dumper
4349*b1cdbd2cSJim Jagielski if (pWwFib->lcbSttbttmbd && (7 < pWwFib->nVersion))
4350*b1cdbd2cSJim Jagielski {
4351*b1cdbd2cSJim Jagielski pTableStream->Seek(pWwFib->fcSttbttmbd);
4352*b1cdbd2cSJim Jagielski sal_uInt16 nZeros;
4353*b1cdbd2cSJim Jagielski *pTableStream >> nZeros;
4354*b1cdbd2cSJim Jagielski sal_uInt16 nNoEntries;
4355*b1cdbd2cSJim Jagielski *pTableStream >> nNoEntries;
4356*b1cdbd2cSJim Jagielski sal_uInt32 nUnknown1;
4357*b1cdbd2cSJim Jagielski *pTableStream >> nUnknown1;
4358*b1cdbd2cSJim Jagielski sal_uInt16 nUnknown2;
4359*b1cdbd2cSJim Jagielski *pTableStream >> nUnknown2;
4360*b1cdbd2cSJim Jagielski std::vector<sal_uInt32> aOffsets;
4361*b1cdbd2cSJim Jagielski for (sal_uInt16 nI = 0; nI < nNoEntries; ++nI)
4362*b1cdbd2cSJim Jagielski {
4363*b1cdbd2cSJim Jagielski sal_uInt32 nOffset;
4364*b1cdbd2cSJim Jagielski *pTableStream >> nOffset;
4365*b1cdbd2cSJim Jagielski aOffsets.push_back(nOffset);
4366*b1cdbd2cSJim Jagielski sal_uInt32 nUnknown3;
4367*b1cdbd2cSJim Jagielski *pTableStream >> nUnknown3;
4368*b1cdbd2cSJim Jagielski sal_uInt32 nUnknown4;
4369*b1cdbd2cSJim Jagielski *pTableStream >> nUnknown4;
4370*b1cdbd2cSJim Jagielski }
4371*b1cdbd2cSJim Jagielski typedef std::vector<sal_uInt32>::iterator myIter;
4372*b1cdbd2cSJim Jagielski myIter aEnd = aOffsets.end();
4373*b1cdbd2cSJim Jagielski myIter aIter = aOffsets.begin();
4374*b1cdbd2cSJim Jagielski while (aIter != aEnd)
4375*b1cdbd2cSJim Jagielski {
4376*b1cdbd2cSJim Jagielski sal_uInt32 nOffset = *aIter;
4377*b1cdbd2cSJim Jagielski sal_uInt32 nLen = STREAM_SEEK_TO_END;
4378*b1cdbd2cSJim Jagielski ++aIter;
4379*b1cdbd2cSJim Jagielski pStrm->Seek(nOffset);
4380*b1cdbd2cSJim Jagielski if (aIter != aEnd)
4381*b1cdbd2cSJim Jagielski nLen = *aIter - nOffset;
4382*b1cdbd2cSJim Jagielski SvStream *pDbg = sw::hack::CreateDebuggingStream(CREATE_CONST_ASC(".ttf.dump"));
4383*b1cdbd2cSJim Jagielski sw::hack::DumpStream(*pStrm, *pDbg, nLen);
4384*b1cdbd2cSJim Jagielski delete pDbg;
4385*b1cdbd2cSJim Jagielski }
4386*b1cdbd2cSJim Jagielski }
4387*b1cdbd2cSJim Jagielski #endif
4388*b1cdbd2cSJim Jagielski
4389*b1cdbd2cSJim Jagielski // read Font Table
4390*b1cdbd2cSJim Jagielski pFonts = new WW8Fonts( *pTableStream, *pWwFib );
4391*b1cdbd2cSJim Jagielski
4392*b1cdbd2cSJim Jagielski // Document Properties
4393*b1cdbd2cSJim Jagielski pWDop = new WW8Dop( *pTableStream, pWwFib->nFib, pWwFib->fcDop,
4394*b1cdbd2cSJim Jagielski pWwFib->lcbDop );
4395*b1cdbd2cSJim Jagielski
4396*b1cdbd2cSJim Jagielski if (mbNewDoc)
4397*b1cdbd2cSJim Jagielski ImportDop();
4398*b1cdbd2cSJim Jagielski
4399*b1cdbd2cSJim Jagielski /*
4400*b1cdbd2cSJim Jagielski Import revisioning data: author names
4401*b1cdbd2cSJim Jagielski */
4402*b1cdbd2cSJim Jagielski if( pWwFib->lcbSttbfRMark )
4403*b1cdbd2cSJim Jagielski {
4404*b1cdbd2cSJim Jagielski ReadRevMarkAuthorStrTabl( *pTableStream,
4405*b1cdbd2cSJim Jagielski pWwFib->fcSttbfRMark,
4406*b1cdbd2cSJim Jagielski pWwFib->lcbSttbfRMark, rDoc );
4407*b1cdbd2cSJim Jagielski }
4408*b1cdbd2cSJim Jagielski
4409*b1cdbd2cSJim Jagielski // M.M. Initialize our String/ID map for Linked Sections
4410*b1cdbd2cSJim Jagielski std::vector<String> aLinkStrings;
4411*b1cdbd2cSJim Jagielski std::vector<ww::bytes> aStringIds;
4412*b1cdbd2cSJim Jagielski
4413*b1cdbd2cSJim Jagielski WW8ReadSTTBF(!bVer67, *pTableStream, pWwFib->fcSttbFnm,
4414*b1cdbd2cSJim Jagielski pWwFib->lcbSttbFnm, bVer67 ? 2 : 0, eStructCharSet,
4415*b1cdbd2cSJim Jagielski aLinkStrings, &aStringIds);
4416*b1cdbd2cSJim Jagielski
4417*b1cdbd2cSJim Jagielski for (size_t i=0; i < aLinkStrings.size(); ++i)
4418*b1cdbd2cSJim Jagielski {
4419*b1cdbd2cSJim Jagielski ww::bytes stringId = aStringIds[i];
4420*b1cdbd2cSJim Jagielski WW8_STRINGID *stringIdStruct = (WW8_STRINGID*)(&stringId[0]);
4421*b1cdbd2cSJim Jagielski aLinkStringMap[SVBT16ToShort(stringIdStruct->nStringId)] =
4422*b1cdbd2cSJim Jagielski aLinkStrings[i];
4423*b1cdbd2cSJim Jagielski }
4424*b1cdbd2cSJim Jagielski
4425*b1cdbd2cSJim Jagielski ReadDocVars(); // import document variables as meta information.
4426*b1cdbd2cSJim Jagielski
4427*b1cdbd2cSJim Jagielski ::SetProgressState(nProgress, mpDocShell); // Update
4428*b1cdbd2cSJim Jagielski
4429*b1cdbd2cSJim Jagielski pLstManager = new WW8ListManager( *pTableStream, *this );
4430*b1cdbd2cSJim Jagielski
4431*b1cdbd2cSJim Jagielski /*
4432*b1cdbd2cSJim Jagielski zuerst(!) alle Styles importieren (siehe WW8PAR2.CXX)
4433*b1cdbd2cSJim Jagielski VOR dem Import der Listen !!
4434*b1cdbd2cSJim Jagielski */
4435*b1cdbd2cSJim Jagielski ::SetProgressState(nProgress, mpDocShell); // Update
4436*b1cdbd2cSJim Jagielski pStyles = new WW8RStyle( *pWwFib, this ); // Styles
4437*b1cdbd2cSJim Jagielski pStyles->Import();
4438*b1cdbd2cSJim Jagielski
4439*b1cdbd2cSJim Jagielski /*
4440*b1cdbd2cSJim Jagielski zu guter Letzt: (siehe ebenfalls WW8PAR3.CXX)
4441*b1cdbd2cSJim Jagielski ===============
4442*b1cdbd2cSJim Jagielski alle Styles durchgehen und ggfs. zugehoeriges Listen-Format
4443*b1cdbd2cSJim Jagielski anhaengen NACH dem Import der Styles und NACH dem Import der
4444*b1cdbd2cSJim Jagielski Listen !!
4445*b1cdbd2cSJim Jagielski */
4446*b1cdbd2cSJim Jagielski ::SetProgressState(nProgress, mpDocShell); // Update
4447*b1cdbd2cSJim Jagielski pStyles->PostProcessStyles();
4448*b1cdbd2cSJim Jagielski
4449*b1cdbd2cSJim Jagielski if (pCollA)
4450*b1cdbd2cSJim Jagielski SetOutlineStyles();
4451*b1cdbd2cSJim Jagielski
4452*b1cdbd2cSJim Jagielski pSBase = new WW8ScannerBase(pStrm,pTableStream,pDataStream,pWwFib);
4453*b1cdbd2cSJim Jagielski
4454*b1cdbd2cSJim Jagielski if ( !pSBase->IsValid() )
4455*b1cdbd2cSJim Jagielski {
4456*b1cdbd2cSJim Jagielski return ERR_SWG_READ_ERROR;
4457*b1cdbd2cSJim Jagielski }
4458*b1cdbd2cSJim Jagielski
4459*b1cdbd2cSJim Jagielski static const SvxExtNumType eNumTA[16] =
4460*b1cdbd2cSJim Jagielski {
4461*b1cdbd2cSJim Jagielski SVX_NUM_ARABIC, SVX_NUM_ROMAN_UPPER, SVX_NUM_ROMAN_LOWER,
4462*b1cdbd2cSJim Jagielski SVX_NUM_CHARS_UPPER_LETTER_N, SVX_NUM_CHARS_LOWER_LETTER_N,
4463*b1cdbd2cSJim Jagielski SVX_NUM_ARABIC, SVX_NUM_ARABIC, SVX_NUM_ARABIC,
4464*b1cdbd2cSJim Jagielski SVX_NUM_ARABIC, SVX_NUM_ARABIC, SVX_NUM_ARABIC,
4465*b1cdbd2cSJim Jagielski SVX_NUM_ARABIC, SVX_NUM_ARABIC, SVX_NUM_ARABIC,
4466*b1cdbd2cSJim Jagielski SVX_NUM_ARABIC, SVX_NUM_ARABIC
4467*b1cdbd2cSJim Jagielski };
4468*b1cdbd2cSJim Jagielski
4469*b1cdbd2cSJim Jagielski if (pSBase->AreThereFootnotes())
4470*b1cdbd2cSJim Jagielski {
4471*b1cdbd2cSJim Jagielski static const SwFtnNum eNumA[4] =
4472*b1cdbd2cSJim Jagielski {
4473*b1cdbd2cSJim Jagielski FTNNUM_DOC, FTNNUM_CHAPTER, FTNNUM_PAGE, FTNNUM_DOC
4474*b1cdbd2cSJim Jagielski };
4475*b1cdbd2cSJim Jagielski
4476*b1cdbd2cSJim Jagielski SwFtnInfo aInfo;
4477*b1cdbd2cSJim Jagielski aInfo = rDoc.GetFtnInfo(); // Copy-Ctor privat
4478*b1cdbd2cSJim Jagielski
4479*b1cdbd2cSJim Jagielski aInfo.ePos = FTNPOS_PAGE;
4480*b1cdbd2cSJim Jagielski aInfo.eNum = eNumA[pWDop->rncFtn];
4481*b1cdbd2cSJim Jagielski aInfo.aFmt.SetNumberingType( static_cast< sal_uInt16 >(eNumTA[pWDop->nfcFtnRef]) );
4482*b1cdbd2cSJim Jagielski if( pWDop->nFtn )
4483*b1cdbd2cSJim Jagielski aInfo.nFtnOffset = pWDop->nFtn - 1;
4484*b1cdbd2cSJim Jagielski rDoc.SetFtnInfo( aInfo );
4485*b1cdbd2cSJim Jagielski }
4486*b1cdbd2cSJim Jagielski if( pSBase->AreThereEndnotes() )
4487*b1cdbd2cSJim Jagielski {
4488*b1cdbd2cSJim Jagielski SwEndNoteInfo aInfo;
4489*b1cdbd2cSJim Jagielski aInfo = rDoc.GetEndNoteInfo(); // parallel zu Ftn
4490*b1cdbd2cSJim Jagielski
4491*b1cdbd2cSJim Jagielski // Ich kann nicht setzen, wann neu nummerieren...
4492*b1cdbd2cSJim Jagielski // aInfo.eNum = eNumA[pWDop->pDop->rncEdn];
4493*b1cdbd2cSJim Jagielski aInfo.aFmt.SetNumberingType( static_cast< sal_uInt16 >(eNumTA[pWDop->nfcEdnRef]) );
4494*b1cdbd2cSJim Jagielski if( pWDop->nEdn )
4495*b1cdbd2cSJim Jagielski aInfo.nFtnOffset = pWDop->nEdn - 1;
4496*b1cdbd2cSJim Jagielski rDoc.SetEndNoteInfo( aInfo );
4497*b1cdbd2cSJim Jagielski }
4498*b1cdbd2cSJim Jagielski
4499*b1cdbd2cSJim Jagielski if( pWwFib->lcbPlcfhdd )
4500*b1cdbd2cSJim Jagielski pHdFt = new WW8PLCF_HdFt( pTableStream, *pWwFib, *pWDop );
4501*b1cdbd2cSJim Jagielski
4502*b1cdbd2cSJim Jagielski if (!mbNewDoc)
4503*b1cdbd2cSJim Jagielski {
4504*b1cdbd2cSJim Jagielski // inserting into an existing document:
4505*b1cdbd2cSJim Jagielski // As only complete paragraphs are inserted, the current one
4506*b1cdbd2cSJim Jagielski // needs to be splitted - once or even twice.
4507*b1cdbd2cSJim Jagielski const SwPosition* pPos = pPaM->GetPoint();
4508*b1cdbd2cSJim Jagielski
4509*b1cdbd2cSJim Jagielski // split current paragraph to get new paragraph for the insertion
4510*b1cdbd2cSJim Jagielski rDoc.SplitNode( *pPos, false );
4511*b1cdbd2cSJim Jagielski
4512*b1cdbd2cSJim Jagielski // another split, if insertion position was not at the end of the current paragraph.
4513*b1cdbd2cSJim Jagielski SwTxtNode const*const pTxtNd = pPos->nNode.GetNode().GetTxtNode();
4514*b1cdbd2cSJim Jagielski if ( pTxtNd->GetTxt().Len() )
4515*b1cdbd2cSJim Jagielski {
4516*b1cdbd2cSJim Jagielski rDoc.SplitNode( *pPos, false );
4517*b1cdbd2cSJim Jagielski // move PaM back to the newly empty paragraph
4518*b1cdbd2cSJim Jagielski pPaM->Move( fnMoveBackward );
4519*b1cdbd2cSJim Jagielski }
4520*b1cdbd2cSJim Jagielski
4521*b1cdbd2cSJim Jagielski // suppress insertion of tables inside footnotes.
4522*b1cdbd2cSJim Jagielski const sal_uLong nNd = pPos->nNode.GetIndex();
4523*b1cdbd2cSJim Jagielski bReadNoTbl = ( nNd < rDoc.GetNodes().GetEndOfInserts().GetIndex() &&
4524*b1cdbd2cSJim Jagielski rDoc.GetNodes().GetEndOfInserts().StartOfSectionIndex() < nNd );
4525*b1cdbd2cSJim Jagielski
4526*b1cdbd2cSJim Jagielski }
4527*b1cdbd2cSJim Jagielski
4528*b1cdbd2cSJim Jagielski ::SetProgressState(nProgress, mpDocShell); // Update
4529*b1cdbd2cSJim Jagielski
4530*b1cdbd2cSJim Jagielski // loop for each glossary entry and add dummy section node
4531*b1cdbd2cSJim Jagielski if (pGloss)
4532*b1cdbd2cSJim Jagielski {
4533*b1cdbd2cSJim Jagielski WW8PLCF aPlc(pTableStream, pWwFib->fcPlcfglsy, pWwFib->lcbPlcfglsy, 0);
4534*b1cdbd2cSJim Jagielski if ( aPlc.IsValid() )
4535*b1cdbd2cSJim Jagielski {
4536*b1cdbd2cSJim Jagielski WW8_CP nStart, nEnd;
4537*b1cdbd2cSJim Jagielski void* pDummy;
4538*b1cdbd2cSJim Jagielski
4539*b1cdbd2cSJim Jagielski for (int i=0; i<pGloss->GetNoStrings(); i++,aPlc++)
4540*b1cdbd2cSJim Jagielski {
4541*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( rDoc.GetNodes().GetEndOfContent());
4542*b1cdbd2cSJim Jagielski SwTxtFmtColl* pColl =
4543*b1cdbd2cSJim Jagielski rDoc.GetTxtCollFromPool(RES_POOLCOLL_STANDARD,
4544*b1cdbd2cSJim Jagielski false);
4545*b1cdbd2cSJim Jagielski SwStartNode *pNode =
4546*b1cdbd2cSJim Jagielski rDoc.GetNodes().MakeTextSection(aIdx,
4547*b1cdbd2cSJim Jagielski SwNormalStartNode,pColl);
4548*b1cdbd2cSJim Jagielski pPaM->GetPoint()->nNode = pNode->GetIndex()+1;
4549*b1cdbd2cSJim Jagielski pPaM->GetPoint()->nContent.Assign(pPaM->GetCntntNode(),0);
4550*b1cdbd2cSJim Jagielski aPlc.Get( nStart, nEnd, pDummy );
4551*b1cdbd2cSJim Jagielski ReadText(nStart,nEnd-nStart-1,MAN_MAINTEXT);
4552*b1cdbd2cSJim Jagielski }
4553*b1cdbd2cSJim Jagielski }
4554*b1cdbd2cSJim Jagielski }
4555*b1cdbd2cSJim Jagielski else //ordinary case
4556*b1cdbd2cSJim Jagielski {
4557*b1cdbd2cSJim Jagielski //Modify here for #119405, by easyfan, 2012-05-24
4558*b1cdbd2cSJim Jagielski mbOnLoadingMain = true;
4559*b1cdbd2cSJim Jagielski //End of modification, by easyfan
4560*b1cdbd2cSJim Jagielski ReadText( 0, pWwFib->ccpText, MAN_MAINTEXT );
4561*b1cdbd2cSJim Jagielski //Modify here for #119405, by easyfan, 2012-05-24
4562*b1cdbd2cSJim Jagielski mbOnLoadingMain = false;
4563*b1cdbd2cSJim Jagielski //End of modification, by easyfan
4564*b1cdbd2cSJim Jagielski }
4565*b1cdbd2cSJim Jagielski
4566*b1cdbd2cSJim Jagielski ::SetProgressState(nProgress, mpDocShell); // Update
4567*b1cdbd2cSJim Jagielski
4568*b1cdbd2cSJim Jagielski if (pDrawPg && pMSDffManager && pMSDffManager->GetShapeOrders())
4569*b1cdbd2cSJim Jagielski {
4570*b1cdbd2cSJim Jagielski // Hilfsarray zum Verketten der (statt SdrTxtObj) eingefuegten
4571*b1cdbd2cSJim Jagielski // Rahmen
4572*b1cdbd2cSJim Jagielski SvxMSDffShapeTxBxSort aTxBxSort;
4573*b1cdbd2cSJim Jagielski
4574*b1cdbd2cSJim Jagielski // korrekte Z-Order der eingelesen Escher-Objekte sicherstellen
4575*b1cdbd2cSJim Jagielski sal_uInt16 nShapeCount = pMSDffManager->GetShapeOrders()->Count();
4576*b1cdbd2cSJim Jagielski
4577*b1cdbd2cSJim Jagielski for (sal_uInt16 nShapeNum=0; nShapeNum < nShapeCount; nShapeNum++)
4578*b1cdbd2cSJim Jagielski {
4579*b1cdbd2cSJim Jagielski SvxMSDffShapeOrder *pOrder =
4580*b1cdbd2cSJim Jagielski pMSDffManager->GetShapeOrders()->GetObject(nShapeNum);
4581*b1cdbd2cSJim Jagielski // Pointer in neues Sort-Array einfuegen
4582*b1cdbd2cSJim Jagielski if (pOrder->nTxBxComp && pOrder->pFly)
4583*b1cdbd2cSJim Jagielski aTxBxSort.Insert(pOrder);
4584*b1cdbd2cSJim Jagielski }
4585*b1cdbd2cSJim Jagielski // zu verkettende Rahmen jetzt verketten
4586*b1cdbd2cSJim Jagielski sal_uInt16 nTxBxCount = aTxBxSort.Count();
4587*b1cdbd2cSJim Jagielski if( nTxBxCount )
4588*b1cdbd2cSJim Jagielski {
4589*b1cdbd2cSJim Jagielski SwFmtChain aChain;
4590*b1cdbd2cSJim Jagielski for (sal_uInt16 nTxBxNum=0; nTxBxNum < nTxBxCount; nTxBxNum++)
4591*b1cdbd2cSJim Jagielski {
4592*b1cdbd2cSJim Jagielski SvxMSDffShapeOrder *pOrder =
4593*b1cdbd2cSJim Jagielski aTxBxSort.GetObject(nTxBxNum);
4594*b1cdbd2cSJim Jagielski
4595*b1cdbd2cSJim Jagielski // Fly-Frame-Formate initialisieren
4596*b1cdbd2cSJim Jagielski SwFlyFrmFmt* pFlyFmt = pOrder->pFly;
4597*b1cdbd2cSJim Jagielski SwFlyFrmFmt* pNextFlyFmt = 0;
4598*b1cdbd2cSJim Jagielski SwFlyFrmFmt* pPrevFlyFmt = 0;
4599*b1cdbd2cSJim Jagielski // ggfs. Nachfolger ermitteln
4600*b1cdbd2cSJim Jagielski if( 1+nTxBxNum < nTxBxCount )
4601*b1cdbd2cSJim Jagielski {
4602*b1cdbd2cSJim Jagielski SvxMSDffShapeOrder *pNextOrder =
4603*b1cdbd2cSJim Jagielski aTxBxSort.GetObject(nTxBxNum+1);
4604*b1cdbd2cSJim Jagielski if ((0xFFFF0000 & pOrder->nTxBxComp)
4605*b1cdbd2cSJim Jagielski == (0xFFFF0000 & pNextOrder->nTxBxComp))
4606*b1cdbd2cSJim Jagielski pNextFlyFmt = pNextOrder->pFly;
4607*b1cdbd2cSJim Jagielski }
4608*b1cdbd2cSJim Jagielski // ggfs. Vorgaenger ermitteln
4609*b1cdbd2cSJim Jagielski if( nTxBxNum )
4610*b1cdbd2cSJim Jagielski {
4611*b1cdbd2cSJim Jagielski SvxMSDffShapeOrder *pPrevOrder =
4612*b1cdbd2cSJim Jagielski aTxBxSort.GetObject(nTxBxNum-1);
4613*b1cdbd2cSJim Jagielski if ((0xFFFF0000 & pOrder->nTxBxComp)
4614*b1cdbd2cSJim Jagielski == (0xFFFF0000 & pPrevOrder->nTxBxComp))
4615*b1cdbd2cSJim Jagielski pPrevFlyFmt = pPrevOrder->pFly;
4616*b1cdbd2cSJim Jagielski }
4617*b1cdbd2cSJim Jagielski // Falls Nachfolger oder Vorgaenger vorhanden,
4618*b1cdbd2cSJim Jagielski // die Verkettung am Fly-Frame-Format eintragen
4619*b1cdbd2cSJim Jagielski if (pNextFlyFmt || pPrevFlyFmt)
4620*b1cdbd2cSJim Jagielski {
4621*b1cdbd2cSJim Jagielski aChain.SetNext( pNextFlyFmt );
4622*b1cdbd2cSJim Jagielski aChain.SetPrev( pPrevFlyFmt );
4623*b1cdbd2cSJim Jagielski pFlyFmt->SetFmtAttr( aChain );
4624*b1cdbd2cSJim Jagielski }
4625*b1cdbd2cSJim Jagielski }
4626*b1cdbd2cSJim Jagielski
4627*b1cdbd2cSJim Jagielski }
4628*b1cdbd2cSJim Jagielski
4629*b1cdbd2cSJim Jagielski }
4630*b1cdbd2cSJim Jagielski
4631*b1cdbd2cSJim Jagielski if (mbNewDoc)
4632*b1cdbd2cSJim Jagielski {
4633*b1cdbd2cSJim Jagielski if( pWDop->fRevMarking )
4634*b1cdbd2cSJim Jagielski eMode |= nsRedlineMode_t::REDLINE_ON;
4635*b1cdbd2cSJim Jagielski if( pWDop->fRMView )
4636*b1cdbd2cSJim Jagielski eMode |= nsRedlineMode_t::REDLINE_SHOW_DELETE;
4637*b1cdbd2cSJim Jagielski if (pStg && !pGloss) /*meaningless for a glossary, cmc*/
4638*b1cdbd2cSJim Jagielski {
4639*b1cdbd2cSJim Jagielski const SvtFilterOptions* pVBAFlags = SvtFilterOptions::Get();
4640*b1cdbd2cSJim Jagielski maTracer.EnterEnvironment(sw::log::eMacros);
4641*b1cdbd2cSJim Jagielski SvxImportMSVBasic aVBasic(*mpDocShell, *pStg,
4642*b1cdbd2cSJim Jagielski pVBAFlags->IsLoadWordBasicCode(),
4643*b1cdbd2cSJim Jagielski pVBAFlags->IsLoadWordBasicStorage() );
4644*b1cdbd2cSJim Jagielski String s1(CREATE_CONST_ASC("Macros"));
4645*b1cdbd2cSJim Jagielski String s2(CREATE_CONST_ASC("VBA"));
4646*b1cdbd2cSJim Jagielski int nRet = aVBasic.Import( s1, s2 );
4647*b1cdbd2cSJim Jagielski if( 2 & nRet )
4648*b1cdbd2cSJim Jagielski {
4649*b1cdbd2cSJim Jagielski maTracer.Log(sw::log::eContainsVisualBasic);
4650*b1cdbd2cSJim Jagielski rDoc.SetContainsMSVBasic(true);
4651*b1cdbd2cSJim Jagielski }
4652*b1cdbd2cSJim Jagielski
4653*b1cdbd2cSJim Jagielski StoreMacroCmds();
4654*b1cdbd2cSJim Jagielski
4655*b1cdbd2cSJim Jagielski maTracer.LeaveEnvironment(sw::log::eMacros);
4656*b1cdbd2cSJim Jagielski }
4657*b1cdbd2cSJim Jagielski }
4658*b1cdbd2cSJim Jagielski
4659*b1cdbd2cSJim Jagielski maInsertedTables.DelAndMakeTblFrms();
4660*b1cdbd2cSJim Jagielski maSectionManager.InsertSegments();
4661*b1cdbd2cSJim Jagielski
4662*b1cdbd2cSJim Jagielski if (pCollA)
4663*b1cdbd2cSJim Jagielski delete[] pCollA;
4664*b1cdbd2cSJim Jagielski
4665*b1cdbd2cSJim Jagielski DELETEZ( pStyles );
4666*b1cdbd2cSJim Jagielski
4667*b1cdbd2cSJim Jagielski if( pFormImpl )
4668*b1cdbd2cSJim Jagielski DeleteFormImpl();
4669*b1cdbd2cSJim Jagielski GrafikDtor();
4670*b1cdbd2cSJim Jagielski DELETEZ( pMSDffManager );
4671*b1cdbd2cSJim Jagielski DELETEZ( pHdFt );
4672*b1cdbd2cSJim Jagielski //For i120928,delay the destruct action
4673*b1cdbd2cSJim Jagielski //DELETEZ( pLstManager );
4674*b1cdbd2cSJim Jagielski DELETEZ( pSBase );
4675*b1cdbd2cSJim Jagielski delete pWDop;
4676*b1cdbd2cSJim Jagielski DELETEZ( pFonts );
4677*b1cdbd2cSJim Jagielski delete mpAtnNames;
4678*b1cdbd2cSJim Jagielski DELETEZ( pAuthorInfos );
4679*b1cdbd2cSJim Jagielski delete mpSprmParser;
4680*b1cdbd2cSJim Jagielski ::EndProgress(mpDocShell);
4681*b1cdbd2cSJim Jagielski
4682*b1cdbd2cSJim Jagielski pDataStream = 0;
4683*b1cdbd2cSJim Jagielski pTableStream = 0;
4684*b1cdbd2cSJim Jagielski
4685*b1cdbd2cSJim Jagielski DeleteCtrlStk();
4686*b1cdbd2cSJim Jagielski mpRedlineStack->closeall(*pPaM->GetPoint());
4687*b1cdbd2cSJim Jagielski delete mpRedlineStack;
4688*b1cdbd2cSJim Jagielski DeleteAnchorStk();
4689*b1cdbd2cSJim Jagielski DeleteRefStks();
4690*b1cdbd2cSJim Jagielski
4691*b1cdbd2cSJim Jagielski //For i120928,achieve the graphics from the special bookmark with is for graphic bullet
4692*b1cdbd2cSJim Jagielski {
4693*b1cdbd2cSJim Jagielski std::vector<const SwGrfNode*> vecBulletGrf;
4694*b1cdbd2cSJim Jagielski std::vector<SwFrmFmt*> vecFrmFmt;
4695*b1cdbd2cSJim Jagielski
4696*b1cdbd2cSJim Jagielski IDocumentMarkAccess* const pMarkAccess =
4697*b1cdbd2cSJim Jagielski rDoc.getIDocumentMarkAccess();
4698*b1cdbd2cSJim Jagielski if ( pMarkAccess )
4699*b1cdbd2cSJim Jagielski {
4700*b1cdbd2cSJim Jagielski IDocumentMarkAccess::const_iterator_t ppBkmk =
4701*b1cdbd2cSJim Jagielski pMarkAccess->findBookmark( C2U("_PictureBullets") );
4702*b1cdbd2cSJim Jagielski if ( ppBkmk != pMarkAccess->getBookmarksEnd()
4703*b1cdbd2cSJim Jagielski && IDocumentMarkAccess::GetType( *(ppBkmk->get()) ) == IDocumentMarkAccess::BOOKMARK )
4704*b1cdbd2cSJim Jagielski {
4705*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNode = ppBkmk->get()->GetMarkStart().nNode.GetNode().GetTxtNode();
4706*b1cdbd2cSJim Jagielski if ( pTxtNode )
4707*b1cdbd2cSJim Jagielski {
4708*b1cdbd2cSJim Jagielski const SwpHints* pHints = pTxtNode->GetpSwpHints();
4709*b1cdbd2cSJim Jagielski for( sal_uInt16 nHintPos = 0; pHints && nHintPos < pHints->Count(); ++nHintPos)
4710*b1cdbd2cSJim Jagielski {
4711*b1cdbd2cSJim Jagielski const SwTxtAttr *pHt = (*pHints)[nHintPos];
4712*b1cdbd2cSJim Jagielski const xub_StrLen st = *(pHt->GetStart());
4713*b1cdbd2cSJim Jagielski if( pHt
4714*b1cdbd2cSJim Jagielski && pHt->Which() == RES_TXTATR_FLYCNT
4715*b1cdbd2cSJim Jagielski && (st >= ppBkmk->get()->GetMarkStart().nContent.GetIndex()) )
4716*b1cdbd2cSJim Jagielski {
4717*b1cdbd2cSJim Jagielski SwFrmFmt* pFrmFmt = pHt->GetFlyCnt().GetFrmFmt();
4718*b1cdbd2cSJim Jagielski vecFrmFmt.push_back(pFrmFmt);
4719*b1cdbd2cSJim Jagielski const SwNodeIndex* pNdIdx = pFrmFmt->GetCntnt().GetCntntIdx();
4720*b1cdbd2cSJim Jagielski const SwNodes* pNodesArray = (pNdIdx != NULL)
4721*b1cdbd2cSJim Jagielski ? &(pNdIdx->GetNodes())
4722*b1cdbd2cSJim Jagielski : NULL;
4723*b1cdbd2cSJim Jagielski const SwGrfNode *pGrf = (pNodesArray != NULL)
4724*b1cdbd2cSJim Jagielski ? dynamic_cast<const SwGrfNode*>((*pNodesArray)[pNdIdx->GetIndex() + 1])
4725*b1cdbd2cSJim Jagielski : NULL;
4726*b1cdbd2cSJim Jagielski vecBulletGrf.push_back(pGrf);
4727*b1cdbd2cSJim Jagielski }
4728*b1cdbd2cSJim Jagielski }
4729*b1cdbd2cSJim Jagielski // update graphic bullet information
4730*b1cdbd2cSJim Jagielski sal_uInt16 nCount = pLstManager->GetWW8LSTInfoNum();
4731*b1cdbd2cSJim Jagielski for (sal_uInt16 i = 0; i < nCount; ++i)
4732*b1cdbd2cSJim Jagielski {
4733*b1cdbd2cSJim Jagielski SwNumRule* pRule = pLstManager->GetNumRule(i);
4734*b1cdbd2cSJim Jagielski for (sal_uInt16 j = 0; j < MAXLEVEL; ++j)
4735*b1cdbd2cSJim Jagielski {
4736*b1cdbd2cSJim Jagielski SwNumFmt aNumFmt(pRule->Get(j));
4737*b1cdbd2cSJim Jagielski const sal_Int16 nType = aNumFmt.GetNumberingType();
4738*b1cdbd2cSJim Jagielski const sal_uInt16 nGrfBulletCP = aNumFmt.GetGrfBulletCP();
4739*b1cdbd2cSJim Jagielski if ( nType == SVX_NUM_BITMAP
4740*b1cdbd2cSJim Jagielski && vecBulletGrf.size() > nGrfBulletCP
4741*b1cdbd2cSJim Jagielski && vecBulletGrf[nGrfBulletCP] != NULL )
4742*b1cdbd2cSJim Jagielski {
4743*b1cdbd2cSJim Jagielski Graphic aGraphic = vecBulletGrf[nGrfBulletCP]->GetGrf();
4744*b1cdbd2cSJim Jagielski SvxBrushItem aBrush(aGraphic, GPOS_AREA, SID_ATTR_BRUSH);
4745*b1cdbd2cSJim Jagielski Font aFont = numfunc::GetDefBulletFont();
4746*b1cdbd2cSJim Jagielski int nHeight = aFont.GetHeight() * 12;
4747*b1cdbd2cSJim Jagielski Size aPrefSize( aGraphic.GetPrefSize());
4748*b1cdbd2cSJim Jagielski if (aPrefSize.Height() * aPrefSize.Width() != 0 )
4749*b1cdbd2cSJim Jagielski {
4750*b1cdbd2cSJim Jagielski int nWidth = (nHeight * aPrefSize.Width()) / aPrefSize.Height();
4751*b1cdbd2cSJim Jagielski Size aSize(nWidth, nHeight);
4752*b1cdbd2cSJim Jagielski aNumFmt.SetGraphicBrush(&aBrush, &aSize);
4753*b1cdbd2cSJim Jagielski }
4754*b1cdbd2cSJim Jagielski else
4755*b1cdbd2cSJim Jagielski {
4756*b1cdbd2cSJim Jagielski aNumFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
4757*b1cdbd2cSJim Jagielski aNumFmt.SetBulletChar(0x2190);
4758*b1cdbd2cSJim Jagielski }
4759*b1cdbd2cSJim Jagielski pRule->Set( j, aNumFmt );
4760*b1cdbd2cSJim Jagielski }
4761*b1cdbd2cSJim Jagielski }
4762*b1cdbd2cSJim Jagielski }
4763*b1cdbd2cSJim Jagielski // Remove additional pictures
4764*b1cdbd2cSJim Jagielski for (sal_uInt16 i = 0; i < vecFrmFmt.size(); ++i)
4765*b1cdbd2cSJim Jagielski {
4766*b1cdbd2cSJim Jagielski rDoc.DelLayoutFmt(vecFrmFmt[i]);
4767*b1cdbd2cSJim Jagielski }
4768*b1cdbd2cSJim Jagielski }
4769*b1cdbd2cSJim Jagielski }
4770*b1cdbd2cSJim Jagielski DELETEZ( pLstManager );
4771*b1cdbd2cSJim Jagielski }
4772*b1cdbd2cSJim Jagielski }
4773*b1cdbd2cSJim Jagielski
4774*b1cdbd2cSJim Jagielski UpdateFields();
4775*b1cdbd2cSJim Jagielski
4776*b1cdbd2cSJim Jagielski // delete the pam before the call for hide all redlines (Bug 73683)
4777*b1cdbd2cSJim Jagielski if (mbNewDoc)
4778*b1cdbd2cSJim Jagielski rDoc.SetRedlineMode((RedlineMode_t)( eMode ));
4779*b1cdbd2cSJim Jagielski
4780*b1cdbd2cSJim Jagielski UpdatePageDescs(rDoc, nPageDescOffset);
4781*b1cdbd2cSJim Jagielski
4782*b1cdbd2cSJim Jagielski delete pPaM, pPaM = 0;
4783*b1cdbd2cSJim Jagielski return nErrRet;
4784*b1cdbd2cSJim Jagielski }
4785*b1cdbd2cSJim Jagielski
SetSubStreams(SvStorageStreamRef & rTableStream,SvStorageStreamRef & rDataStream)4786*b1cdbd2cSJim Jagielski sal_uLong SwWW8ImplReader::SetSubStreams(SvStorageStreamRef &rTableStream,
4787*b1cdbd2cSJim Jagielski SvStorageStreamRef &rDataStream)
4788*b1cdbd2cSJim Jagielski {
4789*b1cdbd2cSJim Jagielski sal_uLong nErrRet = 0;
4790*b1cdbd2cSJim Jagielski // 6 stands for "6 OR 7", 7 stand for "ONLY 7"
4791*b1cdbd2cSJim Jagielski switch (pWwFib->nVersion)
4792*b1cdbd2cSJim Jagielski {
4793*b1cdbd2cSJim Jagielski case 6:
4794*b1cdbd2cSJim Jagielski case 7:
4795*b1cdbd2cSJim Jagielski pTableStream = pStrm;
4796*b1cdbd2cSJim Jagielski pDataStream = pStrm;
4797*b1cdbd2cSJim Jagielski break;
4798*b1cdbd2cSJim Jagielski case 8:
4799*b1cdbd2cSJim Jagielski if(!pStg)
4800*b1cdbd2cSJim Jagielski {
4801*b1cdbd2cSJim Jagielski ASSERT( pStg, "Version 8 muss immer einen Storage haben!" );
4802*b1cdbd2cSJim Jagielski nErrRet = ERR_SWG_READ_ERROR;
4803*b1cdbd2cSJim Jagielski break;
4804*b1cdbd2cSJim Jagielski }
4805*b1cdbd2cSJim Jagielski
4806*b1cdbd2cSJim Jagielski rTableStream = pStg->OpenSotStream( String::CreateFromAscii(
4807*b1cdbd2cSJim Jagielski pWwFib->fWhichTblStm ? SL::a1Table : SL::a0Table),
4808*b1cdbd2cSJim Jagielski STREAM_STD_READ);
4809*b1cdbd2cSJim Jagielski
4810*b1cdbd2cSJim Jagielski pTableStream = &rTableStream;
4811*b1cdbd2cSJim Jagielski pTableStream->SetNumberFormatInt( NUMBERFORMAT_INT_LITTLEENDIAN );
4812*b1cdbd2cSJim Jagielski
4813*b1cdbd2cSJim Jagielski rDataStream = pStg->OpenSotStream(CREATE_CONST_ASC(SL::aData),
4814*b1cdbd2cSJim Jagielski STREAM_STD_READ | STREAM_NOCREATE );
4815*b1cdbd2cSJim Jagielski
4816*b1cdbd2cSJim Jagielski if (rDataStream.Is() && SVSTREAM_OK == rDataStream->GetError())
4817*b1cdbd2cSJim Jagielski {
4818*b1cdbd2cSJim Jagielski pDataStream = &rDataStream;
4819*b1cdbd2cSJim Jagielski pDataStream->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
4820*b1cdbd2cSJim Jagielski }
4821*b1cdbd2cSJim Jagielski else
4822*b1cdbd2cSJim Jagielski pDataStream = pStrm;
4823*b1cdbd2cSJim Jagielski break;
4824*b1cdbd2cSJim Jagielski default:
4825*b1cdbd2cSJim Jagielski // Programm-Fehler!
4826*b1cdbd2cSJim Jagielski ASSERT( !this, "Es wurde vergessen, nVersion zu kodieren!" );
4827*b1cdbd2cSJim Jagielski nErrRet = ERR_SWG_READ_ERROR;
4828*b1cdbd2cSJim Jagielski break;
4829*b1cdbd2cSJim Jagielski }
4830*b1cdbd2cSJim Jagielski return nErrRet;
4831*b1cdbd2cSJim Jagielski }
4832*b1cdbd2cSJim Jagielski
4833*b1cdbd2cSJim Jagielski namespace
4834*b1cdbd2cSJim Jagielski {
MakeTemp(SvFileStream & rSt)4835*b1cdbd2cSJim Jagielski utl::TempFile *MakeTemp(SvFileStream &rSt)
4836*b1cdbd2cSJim Jagielski {
4837*b1cdbd2cSJim Jagielski utl::TempFile *pT = new utl::TempFile;
4838*b1cdbd2cSJim Jagielski pT->EnableKillingFile();
4839*b1cdbd2cSJim Jagielski rSt.Open(pT->GetFileName(), STREAM_READWRITE | STREAM_SHARE_DENYWRITE);
4840*b1cdbd2cSJim Jagielski return pT;
4841*b1cdbd2cSJim Jagielski }
4842*b1cdbd2cSJim Jagielski
4843*b1cdbd2cSJim Jagielski #define WW_BLOCKSIZE 0x200
4844*b1cdbd2cSJim Jagielski
DecryptRC4(msfilter::MSCodec_Std97 & rCtx,SvStream & rIn,SvStream & rOut)4845*b1cdbd2cSJim Jagielski void DecryptRC4(msfilter::MSCodec_Std97& rCtx, SvStream &rIn, SvStream &rOut)
4846*b1cdbd2cSJim Jagielski {
4847*b1cdbd2cSJim Jagielski rIn.Seek(STREAM_SEEK_TO_END);
4848*b1cdbd2cSJim Jagielski sal_uLong nLen = rIn.Tell();
4849*b1cdbd2cSJim Jagielski rIn.Seek(0);
4850*b1cdbd2cSJim Jagielski
4851*b1cdbd2cSJim Jagielski sal_uInt8 in[WW_BLOCKSIZE];
4852*b1cdbd2cSJim Jagielski for (sal_uLong nI = 0, nBlock = 0; nI < nLen; nI += WW_BLOCKSIZE, ++nBlock)
4853*b1cdbd2cSJim Jagielski {
4854*b1cdbd2cSJim Jagielski sal_uLong nBS = (nLen - nI > WW_BLOCKSIZE) ? WW_BLOCKSIZE : nLen - nI;
4855*b1cdbd2cSJim Jagielski rIn.Read(in, nBS);
4856*b1cdbd2cSJim Jagielski rCtx.InitCipher(nBlock);
4857*b1cdbd2cSJim Jagielski rCtx.Decode(in, nBS, in, nBS);
4858*b1cdbd2cSJim Jagielski rOut.Write(in, nBS);
4859*b1cdbd2cSJim Jagielski }
4860*b1cdbd2cSJim Jagielski }
4861*b1cdbd2cSJim Jagielski
DecryptXOR(msfilter::MSCodec_XorWord95 & rCtx,SvStream & rIn,SvStream & rOut)4862*b1cdbd2cSJim Jagielski void DecryptXOR(msfilter::MSCodec_XorWord95 &rCtx, SvStream &rIn, SvStream &rOut)
4863*b1cdbd2cSJim Jagielski {
4864*b1cdbd2cSJim Jagielski sal_uLong nSt = rIn.Tell();
4865*b1cdbd2cSJim Jagielski rIn.Seek(STREAM_SEEK_TO_END);
4866*b1cdbd2cSJim Jagielski sal_uLong nLen = rIn.Tell();
4867*b1cdbd2cSJim Jagielski rIn.Seek(nSt);
4868*b1cdbd2cSJim Jagielski
4869*b1cdbd2cSJim Jagielski rCtx.InitCipher();
4870*b1cdbd2cSJim Jagielski rCtx.Skip(nSt);
4871*b1cdbd2cSJim Jagielski
4872*b1cdbd2cSJim Jagielski sal_uInt8 in[0x4096];
4873*b1cdbd2cSJim Jagielski for (sal_uLong nI = nSt; nI < nLen; nI += 0x4096)
4874*b1cdbd2cSJim Jagielski {
4875*b1cdbd2cSJim Jagielski sal_uLong nBS = (nLen - nI > 0x4096 ) ? 0x4096 : nLen - nI;
4876*b1cdbd2cSJim Jagielski rIn.Read(in, nBS);
4877*b1cdbd2cSJim Jagielski rCtx.Decode(in, nBS);
4878*b1cdbd2cSJim Jagielski rOut.Write(in, nBS);
4879*b1cdbd2cSJim Jagielski }
4880*b1cdbd2cSJim Jagielski }
4881*b1cdbd2cSJim Jagielski
4882*b1cdbd2cSJim Jagielski //moan, copy and paste :-(
QueryPasswordForMedium(SfxMedium & rMedium)4883*b1cdbd2cSJim Jagielski String QueryPasswordForMedium(SfxMedium& rMedium)
4884*b1cdbd2cSJim Jagielski {
4885*b1cdbd2cSJim Jagielski String aPassw;
4886*b1cdbd2cSJim Jagielski
4887*b1cdbd2cSJim Jagielski using namespace com::sun::star;
4888*b1cdbd2cSJim Jagielski
4889*b1cdbd2cSJim Jagielski const SfxItemSet* pSet = rMedium.GetItemSet();
4890*b1cdbd2cSJim Jagielski const SfxPoolItem *pPasswordItem;
4891*b1cdbd2cSJim Jagielski
4892*b1cdbd2cSJim Jagielski if(pSet && SFX_ITEM_SET == pSet->GetItemState(SID_PASSWORD, sal_True, &pPasswordItem))
4893*b1cdbd2cSJim Jagielski aPassw = ((const SfxStringItem *)pPasswordItem)->GetValue();
4894*b1cdbd2cSJim Jagielski else
4895*b1cdbd2cSJim Jagielski {
4896*b1cdbd2cSJim Jagielski try
4897*b1cdbd2cSJim Jagielski {
4898*b1cdbd2cSJim Jagielski uno::Reference< task::XInteractionHandler > xHandler( rMedium.GetInteractionHandler() );
4899*b1cdbd2cSJim Jagielski if( xHandler.is() )
4900*b1cdbd2cSJim Jagielski {
4901*b1cdbd2cSJim Jagielski ::comphelper::DocPasswordRequest* pRequest = new ::comphelper::DocPasswordRequest(
4902*b1cdbd2cSJim Jagielski ::comphelper::DocPasswordRequestType_MS, task::PasswordRequestMode_PASSWORD_ENTER,
4903*b1cdbd2cSJim Jagielski INetURLObject( rMedium.GetOrigURL() ).GetName( INetURLObject::DECODE_WITH_CHARSET ) );
4904*b1cdbd2cSJim Jagielski uno::Reference< task::XInteractionRequest > xRequest( pRequest );
4905*b1cdbd2cSJim Jagielski
4906*b1cdbd2cSJim Jagielski xHandler->handle( xRequest );
4907*b1cdbd2cSJim Jagielski
4908*b1cdbd2cSJim Jagielski if( pRequest->isPassword() )
4909*b1cdbd2cSJim Jagielski aPassw = pRequest->getPassword();
4910*b1cdbd2cSJim Jagielski }
4911*b1cdbd2cSJim Jagielski }
4912*b1cdbd2cSJim Jagielski catch( uno::Exception& )
4913*b1cdbd2cSJim Jagielski {
4914*b1cdbd2cSJim Jagielski }
4915*b1cdbd2cSJim Jagielski }
4916*b1cdbd2cSJim Jagielski
4917*b1cdbd2cSJim Jagielski return aPassw;
4918*b1cdbd2cSJim Jagielski }
4919*b1cdbd2cSJim Jagielski
InitXorWord95Codec(::msfilter::MSCodec_XorWord95 & rCodec,SfxMedium & rMedium,WW8Fib * pWwFib)4920*b1cdbd2cSJim Jagielski uno::Sequence< beans::NamedValue > InitXorWord95Codec( ::msfilter::MSCodec_XorWord95& rCodec, SfxMedium& rMedium, WW8Fib* pWwFib )
4921*b1cdbd2cSJim Jagielski {
4922*b1cdbd2cSJim Jagielski uno::Sequence< beans::NamedValue > aEncryptionData;
4923*b1cdbd2cSJim Jagielski SFX_ITEMSET_ARG( rMedium.GetItemSet(), pEncryptionData, SfxUnoAnyItem, SID_ENCRYPTIONDATA, sal_False );
4924*b1cdbd2cSJim Jagielski if ( pEncryptionData && ( pEncryptionData->GetValue() >>= aEncryptionData ) && !rCodec.InitCodec( aEncryptionData ) )
4925*b1cdbd2cSJim Jagielski aEncryptionData.realloc( 0 );
4926*b1cdbd2cSJim Jagielski
4927*b1cdbd2cSJim Jagielski if ( !aEncryptionData.getLength() )
4928*b1cdbd2cSJim Jagielski {
4929*b1cdbd2cSJim Jagielski String sUniPassword = QueryPasswordForMedium( rMedium );
4930*b1cdbd2cSJim Jagielski
4931*b1cdbd2cSJim Jagielski ByteString sPassword(sUniPassword, WW8Fib::GetFIBCharset( pWwFib->chseTables ) );
4932*b1cdbd2cSJim Jagielski
4933*b1cdbd2cSJim Jagielski xub_StrLen nLen = sPassword.Len();
4934*b1cdbd2cSJim Jagielski if( nLen <= 15 )
4935*b1cdbd2cSJim Jagielski {
4936*b1cdbd2cSJim Jagielski sal_uInt8 pPassword[16];
4937*b1cdbd2cSJim Jagielski memset( pPassword, 0, sizeof( pPassword ) );
4938*b1cdbd2cSJim Jagielski
4939*b1cdbd2cSJim Jagielski for (xub_StrLen nChar = 0; nChar < sPassword.Len(); ++nChar )
4940*b1cdbd2cSJim Jagielski pPassword[nChar] = sPassword.GetChar(nChar);
4941*b1cdbd2cSJim Jagielski
4942*b1cdbd2cSJim Jagielski rCodec.InitKey( pPassword );
4943*b1cdbd2cSJim Jagielski aEncryptionData = rCodec.GetEncryptionData();
4944*b1cdbd2cSJim Jagielski
4945*b1cdbd2cSJim Jagielski // the export supports RC4 algorithm only, so we have to generate the related EncryptionData as well,
4946*b1cdbd2cSJim Jagielski // so that Save can export the document without asking for a password;
4947*b1cdbd2cSJim Jagielski // as result there will be EncryptionData for both algorithms in the MediaDescriptor
4948*b1cdbd2cSJim Jagielski ::msfilter::MSCodec_Std97 aCodec97;
4949*b1cdbd2cSJim Jagielski
4950*b1cdbd2cSJim Jagielski // Generate random number with a seed of time as salt.
4951*b1cdbd2cSJim Jagielski TimeValue aTime;
4952*b1cdbd2cSJim Jagielski osl_getSystemTime( &aTime );
4953*b1cdbd2cSJim Jagielski rtlRandomPool aRandomPool = rtl_random_createPool();
4954*b1cdbd2cSJim Jagielski rtl_random_addBytes ( aRandomPool, &aTime, 8 );
4955*b1cdbd2cSJim Jagielski
4956*b1cdbd2cSJim Jagielski sal_uInt8 pDocId[ 16 ];
4957*b1cdbd2cSJim Jagielski rtl_random_getBytes( aRandomPool, pDocId, 16 );
4958*b1cdbd2cSJim Jagielski
4959*b1cdbd2cSJim Jagielski rtl_random_destroyPool( aRandomPool );
4960*b1cdbd2cSJim Jagielski
4961*b1cdbd2cSJim Jagielski sal_uInt16 pStd97Pass[16];
4962*b1cdbd2cSJim Jagielski memset( pStd97Pass, 0, sizeof( pStd97Pass ) );
4963*b1cdbd2cSJim Jagielski for (xub_StrLen nChar = 0; nChar < nLen; ++nChar )
4964*b1cdbd2cSJim Jagielski pStd97Pass[nChar] = sUniPassword.GetChar(nChar);
4965*b1cdbd2cSJim Jagielski
4966*b1cdbd2cSJim Jagielski aCodec97.InitKey( pStd97Pass, pDocId );
4967*b1cdbd2cSJim Jagielski
4968*b1cdbd2cSJim Jagielski // merge the EncryptionData, there should be no conflicts
4969*b1cdbd2cSJim Jagielski ::comphelper::SequenceAsHashMap aEncryptionHash( aEncryptionData );
4970*b1cdbd2cSJim Jagielski aEncryptionHash.update( ::comphelper::SequenceAsHashMap( aCodec97.GetEncryptionData() ) );
4971*b1cdbd2cSJim Jagielski aEncryptionHash >> aEncryptionData;
4972*b1cdbd2cSJim Jagielski }
4973*b1cdbd2cSJim Jagielski }
4974*b1cdbd2cSJim Jagielski
4975*b1cdbd2cSJim Jagielski return aEncryptionData;
4976*b1cdbd2cSJim Jagielski }
4977*b1cdbd2cSJim Jagielski
InitStd97Codec(::msfilter::MSCodec_Std97 & rCodec,sal_uInt8 pDocId[16],SfxMedium & rMedium)4978*b1cdbd2cSJim Jagielski uno::Sequence< beans::NamedValue > InitStd97Codec( ::msfilter::MSCodec_Std97& rCodec, sal_uInt8 pDocId[16], SfxMedium& rMedium )
4979*b1cdbd2cSJim Jagielski {
4980*b1cdbd2cSJim Jagielski uno::Sequence< beans::NamedValue > aEncryptionData;
4981*b1cdbd2cSJim Jagielski SFX_ITEMSET_ARG( rMedium.GetItemSet(), pEncryptionData, SfxUnoAnyItem, SID_ENCRYPTIONDATA, sal_False );
4982*b1cdbd2cSJim Jagielski if ( pEncryptionData && ( pEncryptionData->GetValue() >>= aEncryptionData ) && !rCodec.InitCodec( aEncryptionData ) )
4983*b1cdbd2cSJim Jagielski aEncryptionData.realloc( 0 );
4984*b1cdbd2cSJim Jagielski
4985*b1cdbd2cSJim Jagielski if ( !aEncryptionData.getLength() )
4986*b1cdbd2cSJim Jagielski {
4987*b1cdbd2cSJim Jagielski String sUniPassword = QueryPasswordForMedium( rMedium );
4988*b1cdbd2cSJim Jagielski
4989*b1cdbd2cSJim Jagielski xub_StrLen nLen = sUniPassword.Len();
4990*b1cdbd2cSJim Jagielski if ( nLen <= 15 )
4991*b1cdbd2cSJim Jagielski {
4992*b1cdbd2cSJim Jagielski sal_Unicode pPassword[16];
4993*b1cdbd2cSJim Jagielski memset( pPassword, 0, sizeof( pPassword ) );
4994*b1cdbd2cSJim Jagielski for (xub_StrLen nChar = 0; nChar < nLen; ++nChar )
4995*b1cdbd2cSJim Jagielski pPassword[nChar] = sUniPassword.GetChar(nChar);
4996*b1cdbd2cSJim Jagielski
4997*b1cdbd2cSJim Jagielski rCodec.InitKey( pPassword, pDocId );
4998*b1cdbd2cSJim Jagielski aEncryptionData = rCodec.GetEncryptionData();
4999*b1cdbd2cSJim Jagielski }
5000*b1cdbd2cSJim Jagielski }
5001*b1cdbd2cSJim Jagielski
5002*b1cdbd2cSJim Jagielski return aEncryptionData;
5003*b1cdbd2cSJim Jagielski }
5004*b1cdbd2cSJim Jagielski }
5005*b1cdbd2cSJim Jagielski
LoadThroughDecryption(SwPaM & rPaM,WW8Glossary * pGloss)5006*b1cdbd2cSJim Jagielski sal_uLong SwWW8ImplReader::LoadThroughDecryption(SwPaM& rPaM ,WW8Glossary *pGloss)
5007*b1cdbd2cSJim Jagielski {
5008*b1cdbd2cSJim Jagielski sal_uLong nErrRet = 0;
5009*b1cdbd2cSJim Jagielski if (pGloss)
5010*b1cdbd2cSJim Jagielski pWwFib = pGloss->GetFib();
5011*b1cdbd2cSJim Jagielski else
5012*b1cdbd2cSJim Jagielski pWwFib = new WW8Fib(*pStrm, nWantedVersion);
5013*b1cdbd2cSJim Jagielski
5014*b1cdbd2cSJim Jagielski if (pWwFib->nFibError)
5015*b1cdbd2cSJim Jagielski nErrRet = ERR_SWG_READ_ERROR;
5016*b1cdbd2cSJim Jagielski
5017*b1cdbd2cSJim Jagielski SvStorageStreamRef xTableStream, xDataStream;
5018*b1cdbd2cSJim Jagielski
5019*b1cdbd2cSJim Jagielski if (!nErrRet)
5020*b1cdbd2cSJim Jagielski nErrRet = SetSubStreams(xTableStream, xDataStream);
5021*b1cdbd2cSJim Jagielski
5022*b1cdbd2cSJim Jagielski utl::TempFile *pTempMain = 0;
5023*b1cdbd2cSJim Jagielski utl::TempFile *pTempTable = 0;
5024*b1cdbd2cSJim Jagielski utl::TempFile *pTempData = 0;
5025*b1cdbd2cSJim Jagielski SvFileStream aDecryptMain;
5026*b1cdbd2cSJim Jagielski SvFileStream aDecryptTable;
5027*b1cdbd2cSJim Jagielski SvFileStream aDecryptData;
5028*b1cdbd2cSJim Jagielski
5029*b1cdbd2cSJim Jagielski bool bDecrypt = false;
5030*b1cdbd2cSJim Jagielski enum {RC4, XOR, Other} eAlgo = Other;
5031*b1cdbd2cSJim Jagielski if (pWwFib->fEncrypted && !nErrRet)
5032*b1cdbd2cSJim Jagielski {
5033*b1cdbd2cSJim Jagielski if (!pGloss)
5034*b1cdbd2cSJim Jagielski {
5035*b1cdbd2cSJim Jagielski bDecrypt = true;
5036*b1cdbd2cSJim Jagielski if (8 != pWwFib->nVersion)
5037*b1cdbd2cSJim Jagielski eAlgo = XOR;
5038*b1cdbd2cSJim Jagielski else
5039*b1cdbd2cSJim Jagielski {
5040*b1cdbd2cSJim Jagielski if (pWwFib->nKey != 0)
5041*b1cdbd2cSJim Jagielski eAlgo = XOR;
5042*b1cdbd2cSJim Jagielski else
5043*b1cdbd2cSJim Jagielski {
5044*b1cdbd2cSJim Jagielski pTableStream->Seek(0);
5045*b1cdbd2cSJim Jagielski sal_uInt32 nEncType;
5046*b1cdbd2cSJim Jagielski *pTableStream >> nEncType;
5047*b1cdbd2cSJim Jagielski if (nEncType == 0x10001)
5048*b1cdbd2cSJim Jagielski eAlgo = RC4;
5049*b1cdbd2cSJim Jagielski }
5050*b1cdbd2cSJim Jagielski }
5051*b1cdbd2cSJim Jagielski }
5052*b1cdbd2cSJim Jagielski }
5053*b1cdbd2cSJim Jagielski
5054*b1cdbd2cSJim Jagielski if (bDecrypt)
5055*b1cdbd2cSJim Jagielski {
5056*b1cdbd2cSJim Jagielski nErrRet = ERRCODE_SVX_WRONGPASS;
5057*b1cdbd2cSJim Jagielski SfxMedium* pMedium = mpDocShell->GetMedium();
5058*b1cdbd2cSJim Jagielski
5059*b1cdbd2cSJim Jagielski if ( pMedium )
5060*b1cdbd2cSJim Jagielski {
5061*b1cdbd2cSJim Jagielski switch (eAlgo)
5062*b1cdbd2cSJim Jagielski {
5063*b1cdbd2cSJim Jagielski default:
5064*b1cdbd2cSJim Jagielski nErrRet = ERRCODE_SVX_READ_FILTER_CRYPT;
5065*b1cdbd2cSJim Jagielski break;
5066*b1cdbd2cSJim Jagielski case XOR:
5067*b1cdbd2cSJim Jagielski {
5068*b1cdbd2cSJim Jagielski msfilter::MSCodec_XorWord95 aCtx;
5069*b1cdbd2cSJim Jagielski uno::Sequence< beans::NamedValue > aEncryptionData = InitXorWord95Codec( aCtx, *pMedium, pWwFib );
5070*b1cdbd2cSJim Jagielski
5071*b1cdbd2cSJim Jagielski // if initialization has failed the EncryptionData should be empty
5072*b1cdbd2cSJim Jagielski if ( aEncryptionData.getLength() && aCtx.VerifyKey( pWwFib->nKey, pWwFib->nHash ) )
5073*b1cdbd2cSJim Jagielski {
5074*b1cdbd2cSJim Jagielski nErrRet = 0;
5075*b1cdbd2cSJim Jagielski pTempMain = MakeTemp(aDecryptMain);
5076*b1cdbd2cSJim Jagielski
5077*b1cdbd2cSJim Jagielski pStrm->Seek(0);
5078*b1cdbd2cSJim Jagielski size_t nUnencryptedHdr =
5079*b1cdbd2cSJim Jagielski (8 == pWwFib->nVersion) ? 0x44 : 0x34;
5080*b1cdbd2cSJim Jagielski sal_uInt8 *pIn = new sal_uInt8[nUnencryptedHdr];
5081*b1cdbd2cSJim Jagielski pStrm->Read(pIn, nUnencryptedHdr);
5082*b1cdbd2cSJim Jagielski aDecryptMain.Write(pIn, nUnencryptedHdr);
5083*b1cdbd2cSJim Jagielski delete [] pIn;
5084*b1cdbd2cSJim Jagielski
5085*b1cdbd2cSJim Jagielski DecryptXOR(aCtx, *pStrm, aDecryptMain);
5086*b1cdbd2cSJim Jagielski
5087*b1cdbd2cSJim Jagielski if (!pTableStream || pTableStream == pStrm)
5088*b1cdbd2cSJim Jagielski pTableStream = &aDecryptMain;
5089*b1cdbd2cSJim Jagielski else
5090*b1cdbd2cSJim Jagielski {
5091*b1cdbd2cSJim Jagielski pTempTable = MakeTemp(aDecryptTable);
5092*b1cdbd2cSJim Jagielski DecryptXOR(aCtx, *pTableStream, aDecryptTable);
5093*b1cdbd2cSJim Jagielski pTableStream = &aDecryptTable;
5094*b1cdbd2cSJim Jagielski }
5095*b1cdbd2cSJim Jagielski
5096*b1cdbd2cSJim Jagielski if (!pDataStream || pDataStream == pStrm)
5097*b1cdbd2cSJim Jagielski pDataStream = &aDecryptMain;
5098*b1cdbd2cSJim Jagielski else
5099*b1cdbd2cSJim Jagielski {
5100*b1cdbd2cSJim Jagielski pTempData = MakeTemp(aDecryptData);
5101*b1cdbd2cSJim Jagielski DecryptXOR(aCtx, *pDataStream, aDecryptData);
5102*b1cdbd2cSJim Jagielski pDataStream = &aDecryptData;
5103*b1cdbd2cSJim Jagielski }
5104*b1cdbd2cSJim Jagielski
5105*b1cdbd2cSJim Jagielski pMedium->GetItemSet()->ClearItem( SID_PASSWORD );
5106*b1cdbd2cSJim Jagielski pMedium->GetItemSet()->Put( SfxUnoAnyItem( SID_ENCRYPTIONDATA, uno::makeAny( aEncryptionData ) ) );
5107*b1cdbd2cSJim Jagielski }
5108*b1cdbd2cSJim Jagielski }
5109*b1cdbd2cSJim Jagielski break;
5110*b1cdbd2cSJim Jagielski case RC4:
5111*b1cdbd2cSJim Jagielski {
5112*b1cdbd2cSJim Jagielski msfilter::MSCodec_Std97 aCtx;
5113*b1cdbd2cSJim Jagielski
5114*b1cdbd2cSJim Jagielski sal_uInt8 aDocId[ 16 ];
5115*b1cdbd2cSJim Jagielski pTableStream->Read(aDocId, 16);
5116*b1cdbd2cSJim Jagielski sal_uInt8 aSaltData[ 16 ];
5117*b1cdbd2cSJim Jagielski pTableStream->Read(aSaltData, 16);
5118*b1cdbd2cSJim Jagielski sal_uInt8 aSaltHash[ 16 ];
5119*b1cdbd2cSJim Jagielski pTableStream->Read(aSaltHash, 16);
5120*b1cdbd2cSJim Jagielski
5121*b1cdbd2cSJim Jagielski // if initialization has failed the EncryptionData should be empty
5122*b1cdbd2cSJim Jagielski uno::Sequence< beans::NamedValue > aEncryptionData = InitStd97Codec( aCtx, aDocId, *pMedium );
5123*b1cdbd2cSJim Jagielski if ( aEncryptionData.getLength() && aCtx.VerifyKey( aSaltData, aSaltHash ) )
5124*b1cdbd2cSJim Jagielski {
5125*b1cdbd2cSJim Jagielski nErrRet = 0;
5126*b1cdbd2cSJim Jagielski
5127*b1cdbd2cSJim Jagielski pTempTable = MakeTemp(aDecryptTable);
5128*b1cdbd2cSJim Jagielski DecryptRC4(aCtx, *pTableStream, aDecryptTable);
5129*b1cdbd2cSJim Jagielski pTableStream = &aDecryptTable;
5130*b1cdbd2cSJim Jagielski
5131*b1cdbd2cSJim Jagielski pTempMain = MakeTemp(aDecryptMain);
5132*b1cdbd2cSJim Jagielski DecryptRC4(aCtx, *pStrm, aDecryptMain);
5133*b1cdbd2cSJim Jagielski
5134*b1cdbd2cSJim Jagielski if (!pDataStream || pDataStream == pStrm)
5135*b1cdbd2cSJim Jagielski pDataStream = &aDecryptMain;
5136*b1cdbd2cSJim Jagielski else
5137*b1cdbd2cSJim Jagielski {
5138*b1cdbd2cSJim Jagielski pTempData = MakeTemp(aDecryptData);
5139*b1cdbd2cSJim Jagielski DecryptRC4(aCtx, *pDataStream, aDecryptData);
5140*b1cdbd2cSJim Jagielski pDataStream = &aDecryptData;
5141*b1cdbd2cSJim Jagielski }
5142*b1cdbd2cSJim Jagielski
5143*b1cdbd2cSJim Jagielski pMedium->GetItemSet()->ClearItem( SID_PASSWORD );
5144*b1cdbd2cSJim Jagielski pMedium->GetItemSet()->Put( SfxUnoAnyItem( SID_ENCRYPTIONDATA, uno::makeAny( aEncryptionData ) ) );
5145*b1cdbd2cSJim Jagielski }
5146*b1cdbd2cSJim Jagielski }
5147*b1cdbd2cSJim Jagielski break;
5148*b1cdbd2cSJim Jagielski }
5149*b1cdbd2cSJim Jagielski }
5150*b1cdbd2cSJim Jagielski
5151*b1cdbd2cSJim Jagielski if (nErrRet == 0)
5152*b1cdbd2cSJim Jagielski {
5153*b1cdbd2cSJim Jagielski pStrm = &aDecryptMain;
5154*b1cdbd2cSJim Jagielski
5155*b1cdbd2cSJim Jagielski delete pWwFib;
5156*b1cdbd2cSJim Jagielski pWwFib = new WW8Fib(*pStrm, nWantedVersion);
5157*b1cdbd2cSJim Jagielski if (pWwFib->nFibError)
5158*b1cdbd2cSJim Jagielski nErrRet = ERR_SWG_READ_ERROR;
5159*b1cdbd2cSJim Jagielski }
5160*b1cdbd2cSJim Jagielski }
5161*b1cdbd2cSJim Jagielski
5162*b1cdbd2cSJim Jagielski if (!nErrRet)
5163*b1cdbd2cSJim Jagielski nErrRet = CoreLoad(pGloss, *rPaM.GetPoint());
5164*b1cdbd2cSJim Jagielski
5165*b1cdbd2cSJim Jagielski delete pTempMain;
5166*b1cdbd2cSJim Jagielski delete pTempTable;
5167*b1cdbd2cSJim Jagielski delete pTempData;
5168*b1cdbd2cSJim Jagielski
5169*b1cdbd2cSJim Jagielski if (!pGloss)
5170*b1cdbd2cSJim Jagielski delete pWwFib;
5171*b1cdbd2cSJim Jagielski return nErrRet;
5172*b1cdbd2cSJim Jagielski }
5173*b1cdbd2cSJim Jagielski
5174*b1cdbd2cSJim Jagielski class outlineeq : public std::unary_function<const SwTxtFmtColl*, bool>
5175*b1cdbd2cSJim Jagielski {
5176*b1cdbd2cSJim Jagielski private:
5177*b1cdbd2cSJim Jagielski sal_uInt8 mnNum;
5178*b1cdbd2cSJim Jagielski public:
outlineeq(sal_uInt8 nNum)5179*b1cdbd2cSJim Jagielski outlineeq(sal_uInt8 nNum) : mnNum(nNum) {}
operator ()(const SwTxtFmtColl * pTest) const5180*b1cdbd2cSJim Jagielski bool operator()(const SwTxtFmtColl *pTest) const
5181*b1cdbd2cSJim Jagielski {
5182*b1cdbd2cSJim Jagielski //return pTest->GetOutlineLevel() == mnNum; //#outline level,zhaojianwei
5183*b1cdbd2cSJim Jagielski return pTest->IsAssignedToListLevelOfOutlineStyle() && pTest->GetAssignedOutlineStyleLevel() == mnNum; //<-end,zhaojianwei
5184*b1cdbd2cSJim Jagielski }
5185*b1cdbd2cSJim Jagielski };
5186*b1cdbd2cSJim Jagielski
5187*b1cdbd2cSJim Jagielski
SetOutlineStyles()5188*b1cdbd2cSJim Jagielski void SwWW8ImplReader::SetOutlineStyles()
5189*b1cdbd2cSJim Jagielski {
5190*b1cdbd2cSJim Jagielski
5191*b1cdbd2cSJim Jagielski // If we are inserted into a document then don't clobber existing outline levels.
5192*b1cdbd2cSJim Jagielski sal_uInt16 nOutlineStyleListLevelWithAssignment = 0;
5193*b1cdbd2cSJim Jagielski if ( !mbNewDoc )
5194*b1cdbd2cSJim Jagielski {
5195*b1cdbd2cSJim Jagielski sw::ParaStyles aOutLined( sw::util::GetParaStyles( rDoc ) );
5196*b1cdbd2cSJim Jagielski sw::util::SortByAssignedOutlineStyleListLevel( aOutLined );
5197*b1cdbd2cSJim Jagielski sw::ParaStyles::reverse_iterator aEnd = aOutLined.rend();
5198*b1cdbd2cSJim Jagielski for ( sw::ParaStyles::reverse_iterator aIter = aOutLined.rbegin(); aIter < aEnd; ++aIter )
5199*b1cdbd2cSJim Jagielski {
5200*b1cdbd2cSJim Jagielski if ( ( *aIter )->IsAssignedToListLevelOfOutlineStyle() )
5201*b1cdbd2cSJim Jagielski nOutlineStyleListLevelWithAssignment |= 1 << ( *aIter )->GetAssignedOutlineStyleLevel();
5202*b1cdbd2cSJim Jagielski else
5203*b1cdbd2cSJim Jagielski break;
5204*b1cdbd2cSJim Jagielski }
5205*b1cdbd2cSJim Jagielski }
5206*b1cdbd2cSJim Jagielski
5207*b1cdbd2cSJim Jagielski // Check applied WW8 list styles at WW8 Built-In Heading Styles
5208*b1cdbd2cSJim Jagielski // - Choose the list style which occurs most often as the one which provides
5209*b1cdbd2cSJim Jagielski // the list level properties for the Outline Style.
5210*b1cdbd2cSJim Jagielski // - Populate temporary list of WW8 Built-In Heading Styles for further iteration
5211*b1cdbd2cSJim Jagielski std::vector< SwWW8StyInf* > aWW8BuiltInHeadingStyles;
5212*b1cdbd2cSJim Jagielski const SwNumRule* pChosenWW8ListStyle = NULL;
5213*b1cdbd2cSJim Jagielski {
5214*b1cdbd2cSJim Jagielski std::map< const SwNumRule*, int > aWW8ListStyleCounts;
5215*b1cdbd2cSJim Jagielski for ( sal_uInt16 nI = 0; nI < nColls; ++nI )
5216*b1cdbd2cSJim Jagielski {
5217*b1cdbd2cSJim Jagielski SwWW8StyInf& rSI = pCollA[nI];
5218*b1cdbd2cSJim Jagielski
5219*b1cdbd2cSJim Jagielski if ( !rSI.IsWW8BuiltInHeadingStyle()
5220*b1cdbd2cSJim Jagielski || !rSI.HasWW8OutlineLevel() )
5221*b1cdbd2cSJim Jagielski {
5222*b1cdbd2cSJim Jagielski continue;
5223*b1cdbd2cSJim Jagielski }
5224*b1cdbd2cSJim Jagielski
5225*b1cdbd2cSJim Jagielski aWW8BuiltInHeadingStyles.push_back( &rSI );
5226*b1cdbd2cSJim Jagielski
5227*b1cdbd2cSJim Jagielski const SwNumRule* pWW8ListStyle = rSI.GetOutlineNumrule();
5228*b1cdbd2cSJim Jagielski if ( pWW8ListStyle != NULL )
5229*b1cdbd2cSJim Jagielski {
5230*b1cdbd2cSJim Jagielski std::map< const SwNumRule*, int >::iterator aCountIter =
5231*b1cdbd2cSJim Jagielski aWW8ListStyleCounts.find( pWW8ListStyle );
5232*b1cdbd2cSJim Jagielski if ( aCountIter == aWW8ListStyleCounts.end() )
5233*b1cdbd2cSJim Jagielski {
5234*b1cdbd2cSJim Jagielski aWW8ListStyleCounts[pWW8ListStyle] = 1;
5235*b1cdbd2cSJim Jagielski }
5236*b1cdbd2cSJim Jagielski else
5237*b1cdbd2cSJim Jagielski {
5238*b1cdbd2cSJim Jagielski ++(aCountIter->second);
5239*b1cdbd2cSJim Jagielski }
5240*b1cdbd2cSJim Jagielski }
5241*b1cdbd2cSJim Jagielski }
5242*b1cdbd2cSJim Jagielski
5243*b1cdbd2cSJim Jagielski int nCurrentMaxCount = 0;
5244*b1cdbd2cSJim Jagielski std::map< const SwNumRule*, int >::iterator aCountIterEnd =
5245*b1cdbd2cSJim Jagielski aWW8ListStyleCounts.end();
5246*b1cdbd2cSJim Jagielski for ( std::map< const SwNumRule*, int >::iterator aIter = aWW8ListStyleCounts.begin();
5247*b1cdbd2cSJim Jagielski aIter != aCountIterEnd;
5248*b1cdbd2cSJim Jagielski ++aIter )
5249*b1cdbd2cSJim Jagielski {
5250*b1cdbd2cSJim Jagielski if ( aIter->second > nCurrentMaxCount )
5251*b1cdbd2cSJim Jagielski {
5252*b1cdbd2cSJim Jagielski nCurrentMaxCount = aIter->second;
5253*b1cdbd2cSJim Jagielski pChosenWW8ListStyle = aIter->first;
5254*b1cdbd2cSJim Jagielski }
5255*b1cdbd2cSJim Jagielski }
5256*b1cdbd2cSJim Jagielski }
5257*b1cdbd2cSJim Jagielski
5258*b1cdbd2cSJim Jagielski // - set list level properties of Outline Style - ODF's list style applied by default to headings
5259*b1cdbd2cSJim Jagielski // - assign corresponding Heading Paragraph Styles to the Outline Style
5260*b1cdbd2cSJim Jagielski // - If a heading Paragraph Styles is not applying the WW8 list style which had been chosen as
5261*b1cdbd2cSJim Jagielski // the one which provides the list level properties for the Outline Style, its assignment to
5262*b1cdbd2cSJim Jagielski // the Outline Style is removed. A potential applied WW8 list style is assigned directly and
5263*b1cdbd2cSJim Jagielski // its default outline level is applied.
5264*b1cdbd2cSJim Jagielski SwNumRule aOutlineRule( *rDoc.GetOutlineNumRule() );
5265*b1cdbd2cSJim Jagielski bool bAppliedChangedOutlineStyle = false;
5266*b1cdbd2cSJim Jagielski std::vector< SwWW8StyInf* >::iterator aStylesIterEnd =
5267*b1cdbd2cSJim Jagielski aWW8BuiltInHeadingStyles.end();
5268*b1cdbd2cSJim Jagielski for ( std::vector< SwWW8StyInf* >::iterator aStyleIter = aWW8BuiltInHeadingStyles.begin();
5269*b1cdbd2cSJim Jagielski aStyleIter != aStylesIterEnd;
5270*b1cdbd2cSJim Jagielski ++aStyleIter )
5271*b1cdbd2cSJim Jagielski {
5272*b1cdbd2cSJim Jagielski SwWW8StyInf* pStyleInf = (*aStyleIter);
5273*b1cdbd2cSJim Jagielski
5274*b1cdbd2cSJim Jagielski const sal_uInt16 nOutlineStyleListLevelOfWW8BuiltInHeadingStyle = 1 << pStyleInf->mnWW8OutlineLevel;
5275*b1cdbd2cSJim Jagielski if ( nOutlineStyleListLevelOfWW8BuiltInHeadingStyle & nOutlineStyleListLevelWithAssignment )
5276*b1cdbd2cSJim Jagielski {
5277*b1cdbd2cSJim Jagielski continue;
5278*b1cdbd2cSJim Jagielski }
5279*b1cdbd2cSJim Jagielski
5280*b1cdbd2cSJim Jagielski if ( pChosenWW8ListStyle != NULL
5281*b1cdbd2cSJim Jagielski && pStyleInf->mnWW8OutlineLevel == pStyleInf->nListLevel )
5282*b1cdbd2cSJim Jagielski {
5283*b1cdbd2cSJim Jagielski const SwNumFmt& rRule = pChosenWW8ListStyle->Get( pStyleInf->mnWW8OutlineLevel );
5284*b1cdbd2cSJim Jagielski aOutlineRule.Set( pStyleInf->mnWW8OutlineLevel, rRule );
5285*b1cdbd2cSJim Jagielski bAppliedChangedOutlineStyle = true;
5286*b1cdbd2cSJim Jagielski }
5287*b1cdbd2cSJim Jagielski
5288*b1cdbd2cSJim Jagielski // in case that there are more styles on this level ignore them
5289*b1cdbd2cSJim Jagielski nOutlineStyleListLevelWithAssignment |= nOutlineStyleListLevelOfWW8BuiltInHeadingStyle;
5290*b1cdbd2cSJim Jagielski
5291*b1cdbd2cSJim Jagielski SwTxtFmtColl* pTxtFmtColl = static_cast<SwTxtFmtColl*>(pStyleInf->pFmt);
5292*b1cdbd2cSJim Jagielski if ( pStyleInf->GetOutlineNumrule() != pChosenWW8ListStyle
5293*b1cdbd2cSJim Jagielski || ( pStyleInf->nListLevel < WW8ListManager::nMaxLevel
5294*b1cdbd2cSJim Jagielski && pStyleInf->mnWW8OutlineLevel != pStyleInf->nListLevel ) )
5295*b1cdbd2cSJim Jagielski {
5296*b1cdbd2cSJim Jagielski // WW8 Built-In Heading Style does not apply the chosen one.
5297*b1cdbd2cSJim Jagielski // --> delete assignment to OutlineStyle, but keep its current outline level
5298*b1cdbd2cSJim Jagielski pTxtFmtColl->DeleteAssignmentToListLevelOfOutlineStyle( false );
5299*b1cdbd2cSJim Jagielski // Apply existing WW8 list style a normal list style at the Paragraph Style
5300*b1cdbd2cSJim Jagielski if ( pStyleInf->GetOutlineNumrule() != NULL )
5301*b1cdbd2cSJim Jagielski {
5302*b1cdbd2cSJim Jagielski pTxtFmtColl->SetFmtAttr( SwNumRuleItem( pStyleInf->GetOutlineNumrule()->GetName() ) );
5303*b1cdbd2cSJim Jagielski }
5304*b1cdbd2cSJim Jagielski // apply default outline level of WW8 Built-in Heading Style
5305*b1cdbd2cSJim Jagielski const sal_uInt8 nOutlineLevel =
5306*b1cdbd2cSJim Jagielski SwWW8StyInf::WW8OutlineLevelToOutlinelevel( pStyleInf->mnWW8OutlineLevel );
5307*b1cdbd2cSJim Jagielski pTxtFmtColl->SetFmtAttr( SfxUInt16Item( RES_PARATR_OUTLINELEVEL, nOutlineLevel ) );
5308*b1cdbd2cSJim Jagielski }
5309*b1cdbd2cSJim Jagielski else
5310*b1cdbd2cSJim Jagielski {
5311*b1cdbd2cSJim Jagielski pTxtFmtColl->AssignToListLevelOfOutlineStyle( pStyleInf->mnWW8OutlineLevel );
5312*b1cdbd2cSJim Jagielski }
5313*b1cdbd2cSJim Jagielski }
5314*b1cdbd2cSJim Jagielski
5315*b1cdbd2cSJim Jagielski if ( bAppliedChangedOutlineStyle )
5316*b1cdbd2cSJim Jagielski {
5317*b1cdbd2cSJim Jagielski rDoc.SetOutlineNumRule(aOutlineRule);
5318*b1cdbd2cSJim Jagielski }
5319*b1cdbd2cSJim Jagielski }
5320*b1cdbd2cSJim Jagielski
GetAnnotationAuthor(sal_uInt16 nIdx)5321*b1cdbd2cSJim Jagielski const String* SwWW8ImplReader::GetAnnotationAuthor(sal_uInt16 nIdx)
5322*b1cdbd2cSJim Jagielski {
5323*b1cdbd2cSJim Jagielski if (!mpAtnNames && pWwFib->lcbGrpStAtnOwners)
5324*b1cdbd2cSJim Jagielski {
5325*b1cdbd2cSJim Jagielski // Authoren bestimmen: steht im TableStream
5326*b1cdbd2cSJim Jagielski mpAtnNames = new ::std::vector<String>;
5327*b1cdbd2cSJim Jagielski SvStream& rStrm = *pTableStream;
5328*b1cdbd2cSJim Jagielski
5329*b1cdbd2cSJim Jagielski long nOldPos = rStrm.Tell();
5330*b1cdbd2cSJim Jagielski rStrm.Seek( pWwFib->fcGrpStAtnOwners );
5331*b1cdbd2cSJim Jagielski
5332*b1cdbd2cSJim Jagielski long nRead = 0, nCount = pWwFib->lcbGrpStAtnOwners;
5333*b1cdbd2cSJim Jagielski while (nRead < nCount)
5334*b1cdbd2cSJim Jagielski {
5335*b1cdbd2cSJim Jagielski if( bVer67 )
5336*b1cdbd2cSJim Jagielski {
5337*b1cdbd2cSJim Jagielski mpAtnNames->push_back(WW8ReadPString(rStrm, false));
5338*b1cdbd2cSJim Jagielski nRead += mpAtnNames->rbegin()->Len() + 1; // Laenge + sal_uInt8 Count
5339*b1cdbd2cSJim Jagielski }
5340*b1cdbd2cSJim Jagielski else
5341*b1cdbd2cSJim Jagielski {
5342*b1cdbd2cSJim Jagielski mpAtnNames->push_back(WW8Read_xstz(rStrm, 0, false));
5343*b1cdbd2cSJim Jagielski // UNICode: doppelte Laenge + sal_uInt16 Count
5344*b1cdbd2cSJim Jagielski nRead += mpAtnNames->rbegin()->Len() * 2 + 2;
5345*b1cdbd2cSJim Jagielski }
5346*b1cdbd2cSJim Jagielski }
5347*b1cdbd2cSJim Jagielski rStrm.Seek( nOldPos );
5348*b1cdbd2cSJim Jagielski }
5349*b1cdbd2cSJim Jagielski
5350*b1cdbd2cSJim Jagielski const String *pRet = 0;
5351*b1cdbd2cSJim Jagielski if (mpAtnNames && nIdx < mpAtnNames->size())
5352*b1cdbd2cSJim Jagielski pRet = &((*mpAtnNames)[nIdx]);
5353*b1cdbd2cSJim Jagielski return pRet;
5354*b1cdbd2cSJim Jagielski }
5355*b1cdbd2cSJim Jagielski
LoadDoc(SwPaM & rPaM,WW8Glossary * pGloss)5356*b1cdbd2cSJim Jagielski sal_uLong SwWW8ImplReader::LoadDoc( SwPaM& rPaM,WW8Glossary *pGloss)
5357*b1cdbd2cSJim Jagielski {
5358*b1cdbd2cSJim Jagielski sal_uLong nErrRet = 0;
5359*b1cdbd2cSJim Jagielski
5360*b1cdbd2cSJim Jagielski {
5361*b1cdbd2cSJim Jagielski static const sal_Char* aNames[ 13 ] = {
5362*b1cdbd2cSJim Jagielski "WinWord/WW", "WinWord/WW8", "WinWord/WWFT",
5363*b1cdbd2cSJim Jagielski "WinWord/WWFLX", "WinWord/WWFLY",
5364*b1cdbd2cSJim Jagielski "WinWord/WWF",
5365*b1cdbd2cSJim Jagielski "WinWord/WWFA0", "WinWord/WWFA1", "WinWord/WWFA2",
5366*b1cdbd2cSJim Jagielski "WinWord/WWFB0", "WinWord/WWFB1", "WinWord/WWFB2",
5367*b1cdbd2cSJim Jagielski "WinWord/RegardHindiDigits"
5368*b1cdbd2cSJim Jagielski };
5369*b1cdbd2cSJim Jagielski sal_uInt32 aVal[ 13 ];
5370*b1cdbd2cSJim Jagielski
5371*b1cdbd2cSJim Jagielski SwFilterOptions aOpt( 13, aNames, aVal );
5372*b1cdbd2cSJim Jagielski
5373*b1cdbd2cSJim Jagielski nIniFlags = aVal[ 0 ];
5374*b1cdbd2cSJim Jagielski nIniFlags1= aVal[ 1 ];
5375*b1cdbd2cSJim Jagielski // schiebt Flys um x twips nach rechts o. links
5376*b1cdbd2cSJim Jagielski nIniFlyDx = aVal[ 3 ];
5377*b1cdbd2cSJim Jagielski nIniFlyDy = aVal[ 4 ];
5378*b1cdbd2cSJim Jagielski
5379*b1cdbd2cSJim Jagielski nFieldFlags = aVal[ 5 ];
5380*b1cdbd2cSJim Jagielski nFieldTagAlways[0] = aVal[ 6 ];
5381*b1cdbd2cSJim Jagielski nFieldTagAlways[1] = aVal[ 7 ];
5382*b1cdbd2cSJim Jagielski nFieldTagAlways[2] = aVal[ 8 ];
5383*b1cdbd2cSJim Jagielski nFieldTagBad[0] = aVal[ 9 ];
5384*b1cdbd2cSJim Jagielski nFieldTagBad[1] = aVal[ 10 ];
5385*b1cdbd2cSJim Jagielski nFieldTagBad[2] = aVal[ 11 ];
5386*b1cdbd2cSJim Jagielski m_bRegardHindiDigits = aVal[ 12 ] > 0;
5387*b1cdbd2cSJim Jagielski }
5388*b1cdbd2cSJim Jagielski
5389*b1cdbd2cSJim Jagielski sal_uInt16 nMagic;
5390*b1cdbd2cSJim Jagielski *pStrm >> nMagic;
5391*b1cdbd2cSJim Jagielski
5392*b1cdbd2cSJim Jagielski // beachte: 6 steht fuer "6 ODER 7", 7 steht fuer "NUR 7"
5393*b1cdbd2cSJim Jagielski switch (nWantedVersion)
5394*b1cdbd2cSJim Jagielski {
5395*b1cdbd2cSJim Jagielski case 6:
5396*b1cdbd2cSJim Jagielski case 7:
5397*b1cdbd2cSJim Jagielski if (
5398*b1cdbd2cSJim Jagielski (0xa5dc != nMagic && 0xa5db != nMagic) &&
5399*b1cdbd2cSJim Jagielski (nMagic < 0xa697 || nMagic > 0xa699)
5400*b1cdbd2cSJim Jagielski )
5401*b1cdbd2cSJim Jagielski {
5402*b1cdbd2cSJim Jagielski //JP 06.05.99: teste auf eigenen 97-Fake!
5403*b1cdbd2cSJim Jagielski if (pStg && 0xa5ec == nMagic)
5404*b1cdbd2cSJim Jagielski {
5405*b1cdbd2cSJim Jagielski sal_uLong nCurPos = pStrm->Tell();
5406*b1cdbd2cSJim Jagielski if (pStrm->Seek(nCurPos + 22))
5407*b1cdbd2cSJim Jagielski {
5408*b1cdbd2cSJim Jagielski sal_uInt32 nfcMin;
5409*b1cdbd2cSJim Jagielski *pStrm >> nfcMin;
5410*b1cdbd2cSJim Jagielski if (0x300 != nfcMin)
5411*b1cdbd2cSJim Jagielski nErrRet = ERR_WW6_NO_WW6_FILE_ERR;
5412*b1cdbd2cSJim Jagielski }
5413*b1cdbd2cSJim Jagielski pStrm->Seek( nCurPos );
5414*b1cdbd2cSJim Jagielski }
5415*b1cdbd2cSJim Jagielski else
5416*b1cdbd2cSJim Jagielski nErrRet = ERR_WW6_NO_WW6_FILE_ERR;
5417*b1cdbd2cSJim Jagielski }
5418*b1cdbd2cSJim Jagielski break;
5419*b1cdbd2cSJim Jagielski case 8:
5420*b1cdbd2cSJim Jagielski if (0xa5ec != nMagic)
5421*b1cdbd2cSJim Jagielski nErrRet = ERR_WW8_NO_WW8_FILE_ERR;
5422*b1cdbd2cSJim Jagielski break;
5423*b1cdbd2cSJim Jagielski default:
5424*b1cdbd2cSJim Jagielski nErrRet = ERR_WW8_NO_WW8_FILE_ERR;
5425*b1cdbd2cSJim Jagielski ASSERT( !this, "Es wurde vergessen, nVersion zu kodieren!" );
5426*b1cdbd2cSJim Jagielski break;
5427*b1cdbd2cSJim Jagielski }
5428*b1cdbd2cSJim Jagielski
5429*b1cdbd2cSJim Jagielski if (!nErrRet)
5430*b1cdbd2cSJim Jagielski nErrRet = LoadThroughDecryption(rPaM ,pGloss);
5431*b1cdbd2cSJim Jagielski
5432*b1cdbd2cSJim Jagielski rDoc.PropagateOutlineRule();
5433*b1cdbd2cSJim Jagielski
5434*b1cdbd2cSJim Jagielski return nErrRet;
5435*b1cdbd2cSJim Jagielski }
5436*b1cdbd2cSJim Jagielski
ImportDOC()5437*b1cdbd2cSJim Jagielski extern "C" SAL_DLLPUBLIC_EXPORT Reader* SAL_CALL ImportDOC()
5438*b1cdbd2cSJim Jagielski {
5439*b1cdbd2cSJim Jagielski return new WW8Reader();
5440*b1cdbd2cSJim Jagielski }
5441*b1cdbd2cSJim Jagielski
Read(SwDoc & rDoc,const String & rBaseURL,SwPaM & rPam,const String &)5442*b1cdbd2cSJim Jagielski sal_uLong WW8Reader::Read(SwDoc &rDoc, const String& rBaseURL, SwPaM &rPam, const String & /* FileName */)
5443*b1cdbd2cSJim Jagielski {
5444*b1cdbd2cSJim Jagielski sal_uInt16 nOldBuffSize = 32768;
5445*b1cdbd2cSJim Jagielski bool bNew = !bInsertMode; // Neues Doc ( kein Einfuegen )
5446*b1cdbd2cSJim Jagielski
5447*b1cdbd2cSJim Jagielski
5448*b1cdbd2cSJim Jagielski SvStorageStreamRef refStrm; // damit uns keiner den Stream klaut
5449*b1cdbd2cSJim Jagielski SvStream* pIn = pStrm;
5450*b1cdbd2cSJim Jagielski
5451*b1cdbd2cSJim Jagielski sal_uLong nRet = 0;
5452*b1cdbd2cSJim Jagielski sal_uInt8 nVersion = 8;
5453*b1cdbd2cSJim Jagielski
5454*b1cdbd2cSJim Jagielski String sFltName = GetFltName();
5455*b1cdbd2cSJim Jagielski if( sFltName.EqualsAscii( "WW6" ) )
5456*b1cdbd2cSJim Jagielski {
5457*b1cdbd2cSJim Jagielski if (pStrm)
5458*b1cdbd2cSJim Jagielski nVersion = 6;
5459*b1cdbd2cSJim Jagielski else
5460*b1cdbd2cSJim Jagielski {
5461*b1cdbd2cSJim Jagielski ASSERT(!this, "WinWord 95 Reader-Read ohne Stream");
5462*b1cdbd2cSJim Jagielski nRet = ERR_SWG_READ_ERROR;
5463*b1cdbd2cSJim Jagielski }
5464*b1cdbd2cSJim Jagielski }
5465*b1cdbd2cSJim Jagielski else
5466*b1cdbd2cSJim Jagielski {
5467*b1cdbd2cSJim Jagielski if( sFltName.EqualsAscii( "CWW6" ) )
5468*b1cdbd2cSJim Jagielski nVersion = 6;
5469*b1cdbd2cSJim Jagielski else if( sFltName.EqualsAscii( "CWW7" ) )
5470*b1cdbd2cSJim Jagielski nVersion = 7;
5471*b1cdbd2cSJim Jagielski
5472*b1cdbd2cSJim Jagielski if( pStg )
5473*b1cdbd2cSJim Jagielski {
5474*b1cdbd2cSJim Jagielski nRet = OpenMainStream( refStrm, nOldBuffSize );
5475*b1cdbd2cSJim Jagielski pIn = &refStrm;
5476*b1cdbd2cSJim Jagielski }
5477*b1cdbd2cSJim Jagielski else
5478*b1cdbd2cSJim Jagielski {
5479*b1cdbd2cSJim Jagielski ASSERT(!this, "WinWord 95/97 Reader-Read ohne Storage");
5480*b1cdbd2cSJim Jagielski nRet = ERR_SWG_READ_ERROR;
5481*b1cdbd2cSJim Jagielski }
5482*b1cdbd2cSJim Jagielski }
5483*b1cdbd2cSJim Jagielski
5484*b1cdbd2cSJim Jagielski if( !nRet )
5485*b1cdbd2cSJim Jagielski {
5486*b1cdbd2cSJim Jagielski //JP 18.01.96: Alle Ueberschriften sind normalerweise ohne
5487*b1cdbd2cSJim Jagielski // Kapitelnummer. Darum hier explizit abschalten
5488*b1cdbd2cSJim Jagielski // weil das Default jetzt wieder auf AN ist.
5489*b1cdbd2cSJim Jagielski if (bNew)
5490*b1cdbd2cSJim Jagielski {
5491*b1cdbd2cSJim Jagielski Reader::SetNoOutlineNum( rDoc );
5492*b1cdbd2cSJim Jagielski // MIB 27.09.96: Umrandung uns Abstaende aus Frm-Vorlagen entf.
5493*b1cdbd2cSJim Jagielski Reader::ResetFrmFmts( rDoc );
5494*b1cdbd2cSJim Jagielski }
5495*b1cdbd2cSJim Jagielski SwWW8ImplReader* pRdr = new SwWW8ImplReader(nVersion, pStg, pIn, rDoc,
5496*b1cdbd2cSJim Jagielski rBaseURL, bNew);
5497*b1cdbd2cSJim Jagielski try
5498*b1cdbd2cSJim Jagielski {
5499*b1cdbd2cSJim Jagielski nRet = pRdr->LoadDoc( rPam );
5500*b1cdbd2cSJim Jagielski }
5501*b1cdbd2cSJim Jagielski catch( const std::exception& )
5502*b1cdbd2cSJim Jagielski {
5503*b1cdbd2cSJim Jagielski nRet = ERR_WW8_NO_WW8_FILE_ERR;
5504*b1cdbd2cSJim Jagielski }
5505*b1cdbd2cSJim Jagielski delete pRdr;
5506*b1cdbd2cSJim Jagielski
5507*b1cdbd2cSJim Jagielski if( refStrm.Is() )
5508*b1cdbd2cSJim Jagielski {
5509*b1cdbd2cSJim Jagielski refStrm->SetBufferSize( nOldBuffSize );
5510*b1cdbd2cSJim Jagielski refStrm.Clear();
5511*b1cdbd2cSJim Jagielski }
5512*b1cdbd2cSJim Jagielski else if (pIn)
5513*b1cdbd2cSJim Jagielski pIn->ResetError();
5514*b1cdbd2cSJim Jagielski
5515*b1cdbd2cSJim Jagielski }
5516*b1cdbd2cSJim Jagielski return nRet;
5517*b1cdbd2cSJim Jagielski }
5518*b1cdbd2cSJim Jagielski
GetReaderType()5519*b1cdbd2cSJim Jagielski int WW8Reader::GetReaderType()
5520*b1cdbd2cSJim Jagielski {
5521*b1cdbd2cSJim Jagielski return SW_STORAGE_READER | SW_STREAM_READER;
5522*b1cdbd2cSJim Jagielski }
5523*b1cdbd2cSJim Jagielski
HasGlossaries() const5524*b1cdbd2cSJim Jagielski sal_Bool WW8Reader::HasGlossaries() const
5525*b1cdbd2cSJim Jagielski {
5526*b1cdbd2cSJim Jagielski return true;
5527*b1cdbd2cSJim Jagielski }
5528*b1cdbd2cSJim Jagielski
ReadGlossaries(SwTextBlocks & rBlocks,sal_Bool bSaveRelFiles) const5529*b1cdbd2cSJim Jagielski sal_Bool WW8Reader::ReadGlossaries(SwTextBlocks& rBlocks, sal_Bool bSaveRelFiles) const
5530*b1cdbd2cSJim Jagielski {
5531*b1cdbd2cSJim Jagielski bool bRet=false;
5532*b1cdbd2cSJim Jagielski
5533*b1cdbd2cSJim Jagielski WW8Reader *pThis = const_cast<WW8Reader *>(this);
5534*b1cdbd2cSJim Jagielski
5535*b1cdbd2cSJim Jagielski sal_uInt16 nOldBuffSize = 32768;
5536*b1cdbd2cSJim Jagielski SvStorageStreamRef refStrm;
5537*b1cdbd2cSJim Jagielski if (!pThis->OpenMainStream(refStrm, nOldBuffSize))
5538*b1cdbd2cSJim Jagielski {
5539*b1cdbd2cSJim Jagielski WW8Glossary aGloss( refStrm, 8, pStg );
5540*b1cdbd2cSJim Jagielski bRet = aGloss.Load( rBlocks, bSaveRelFiles ? true : false);
5541*b1cdbd2cSJim Jagielski }
5542*b1cdbd2cSJim Jagielski return bRet ? true : false;
5543*b1cdbd2cSJim Jagielski }
5544*b1cdbd2cSJim Jagielski
GetOLEStorageName(long nOLEId,String & rStorageName,SvStorageRef & rSrcStorage,uno::Reference<embed::XStorage> & rDestStorage) const5545*b1cdbd2cSJim Jagielski sal_Bool SwMSDffManager::GetOLEStorageName(long nOLEId, String& rStorageName,
5546*b1cdbd2cSJim Jagielski SvStorageRef& rSrcStorage, uno::Reference < embed::XStorage >& rDestStorage) const
5547*b1cdbd2cSJim Jagielski {
5548*b1cdbd2cSJim Jagielski bool bRet = false;
5549*b1cdbd2cSJim Jagielski
5550*b1cdbd2cSJim Jagielski long nPictureId = 0;
5551*b1cdbd2cSJim Jagielski if (rReader.pStg)
5552*b1cdbd2cSJim Jagielski {
5553*b1cdbd2cSJim Jagielski // dann holen wir uns mal ueber den TextBox-PLCF die richtigen
5554*b1cdbd2cSJim Jagielski // Char Start-/End-Positionen. In dem Bereich sollte dann
5555*b1cdbd2cSJim Jagielski // das EinbettenFeld und die entsprechenden Sprms zu finden
5556*b1cdbd2cSJim Jagielski // sein. Wir brauchen hier aber nur das Sprm fuer die Picture Id
5557*b1cdbd2cSJim Jagielski long nOldPos = rReader.pStrm->Tell();
5558*b1cdbd2cSJim Jagielski {
5559*b1cdbd2cSJim Jagielski // #i32596# - consider return value of method
5560*b1cdbd2cSJim Jagielski // <rReader.GetTxbxTextSttEndCp(..)>. If it returns false, method
5561*b1cdbd2cSJim Jagielski // wasn't successful. Thus, continue in this case.
5562*b1cdbd2cSJim Jagielski // Note: Ask MM for initialization of <nStartCp> and <nEndCp>.
5563*b1cdbd2cSJim Jagielski // Note: Ask MM about assertions in method <rReader.GetTxbxTextSttEndCp(..)>.
5564*b1cdbd2cSJim Jagielski WW8_CP nStartCp, nEndCp;
5565*b1cdbd2cSJim Jagielski if ( rReader.GetTxbxTextSttEndCp(nStartCp, nEndCp,
5566*b1cdbd2cSJim Jagielski static_cast<sal_uInt16>((nOLEId >> 16) & 0xFFFF),
5567*b1cdbd2cSJim Jagielski static_cast<sal_uInt16>(nOLEId & 0xFFFF)) )
5568*b1cdbd2cSJim Jagielski {
5569*b1cdbd2cSJim Jagielski WW8PLCFxSaveAll aSave;
5570*b1cdbd2cSJim Jagielski memset( &aSave, 0, sizeof( aSave ) );
5571*b1cdbd2cSJim Jagielski rReader.pPlcxMan->SaveAllPLCFx( aSave );
5572*b1cdbd2cSJim Jagielski
5573*b1cdbd2cSJim Jagielski nStartCp += rReader.nDrawCpO;
5574*b1cdbd2cSJim Jagielski nEndCp += rReader.nDrawCpO;
5575*b1cdbd2cSJim Jagielski WW8PLCFx_Cp_FKP* pChp = rReader.pPlcxMan->GetChpPLCF();
5576*b1cdbd2cSJim Jagielski wwSprmParser aSprmParser(rReader.pWwFib->GetFIBVersion());
5577*b1cdbd2cSJim Jagielski while (nStartCp <= nEndCp && !nPictureId)
5578*b1cdbd2cSJim Jagielski {
5579*b1cdbd2cSJim Jagielski WW8PLCFxDesc aDesc;
5580*b1cdbd2cSJim Jagielski pChp->SeekPos( nStartCp );
5581*b1cdbd2cSJim Jagielski pChp->GetSprms( &aDesc );
5582*b1cdbd2cSJim Jagielski
5583*b1cdbd2cSJim Jagielski if (aDesc.nSprmsLen && aDesc.pMemPos) // Attribut(e) vorhanden
5584*b1cdbd2cSJim Jagielski {
5585*b1cdbd2cSJim Jagielski long nLen = aDesc.nSprmsLen;
5586*b1cdbd2cSJim Jagielski const sal_uInt8* pSprm = aDesc.pMemPos;
5587*b1cdbd2cSJim Jagielski
5588*b1cdbd2cSJim Jagielski while (nLen >= 2 && !nPictureId)
5589*b1cdbd2cSJim Jagielski {
5590*b1cdbd2cSJim Jagielski sal_uInt16 nId = aSprmParser.GetSprmId(pSprm);
5591*b1cdbd2cSJim Jagielski sal_uInt16 nSL = aSprmParser.GetSprmSize(nId, pSprm);
5592*b1cdbd2cSJim Jagielski
5593*b1cdbd2cSJim Jagielski if( nLen < nSL )
5594*b1cdbd2cSJim Jagielski break; // nicht mehr genug Bytes uebrig
5595*b1cdbd2cSJim Jagielski
5596*b1cdbd2cSJim Jagielski if( 0x6A03 == nId && 0 < nLen )
5597*b1cdbd2cSJim Jagielski {
5598*b1cdbd2cSJim Jagielski nPictureId = SVBT32ToUInt32(pSprm +
5599*b1cdbd2cSJim Jagielski aSprmParser.DistanceToData(nId));
5600*b1cdbd2cSJim Jagielski bRet = true;
5601*b1cdbd2cSJim Jagielski }
5602*b1cdbd2cSJim Jagielski pSprm += nSL;
5603*b1cdbd2cSJim Jagielski nLen -= nSL;
5604*b1cdbd2cSJim Jagielski }
5605*b1cdbd2cSJim Jagielski }
5606*b1cdbd2cSJim Jagielski nStartCp = aDesc.nEndPos;
5607*b1cdbd2cSJim Jagielski }
5608*b1cdbd2cSJim Jagielski
5609*b1cdbd2cSJim Jagielski rReader.pPlcxMan->RestoreAllPLCFx( aSave );
5610*b1cdbd2cSJim Jagielski }
5611*b1cdbd2cSJim Jagielski }
5612*b1cdbd2cSJim Jagielski rReader.pStrm->Seek( nOldPos );
5613*b1cdbd2cSJim Jagielski }
5614*b1cdbd2cSJim Jagielski
5615*b1cdbd2cSJim Jagielski if( bRet )
5616*b1cdbd2cSJim Jagielski {
5617*b1cdbd2cSJim Jagielski rStorageName = '_';
5618*b1cdbd2cSJim Jagielski rStorageName += String::CreateFromInt32(nPictureId);
5619*b1cdbd2cSJim Jagielski rSrcStorage = rReader.pStg->OpenSotStorage(CREATE_CONST_ASC(
5620*b1cdbd2cSJim Jagielski SL::aObjectPool));
5621*b1cdbd2cSJim Jagielski if (!rReader.mpDocShell)
5622*b1cdbd2cSJim Jagielski bRet=false;
5623*b1cdbd2cSJim Jagielski else
5624*b1cdbd2cSJim Jagielski rDestStorage = rReader.mpDocShell->GetStorage();
5625*b1cdbd2cSJim Jagielski }
5626*b1cdbd2cSJim Jagielski return bRet;
5627*b1cdbd2cSJim Jagielski }
5628*b1cdbd2cSJim Jagielski
ShapeHasText(sal_uLong,sal_uLong) const5629*b1cdbd2cSJim Jagielski sal_Bool SwMSDffManager::ShapeHasText(sal_uLong, sal_uLong) const
5630*b1cdbd2cSJim Jagielski {
5631*b1cdbd2cSJim Jagielski // Zur Zeit des Einlesens einer einzelnen Box, die womoeglich Teil einer
5632*b1cdbd2cSJim Jagielski // Gruppe ist, liegen noch nicht genuegend Informationen vor, um
5633*b1cdbd2cSJim Jagielski // entscheiden zu koennen, ob wir sie nicht doch als Textfeld benoetigen.
5634*b1cdbd2cSJim Jagielski // Also vorsichtshalber mal alle umwandeln:
5635*b1cdbd2cSJim Jagielski return true;
5636*b1cdbd2cSJim Jagielski }
5637*b1cdbd2cSJim Jagielski
InEqualOrHigherApo(int nLvl) const5638*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::InEqualOrHigherApo(int nLvl) const
5639*b1cdbd2cSJim Jagielski {
5640*b1cdbd2cSJim Jagielski if (nLvl)
5641*b1cdbd2cSJim Jagielski --nLvl;
5642*b1cdbd2cSJim Jagielski // #i60827# - check size of <maApos> to assure that <maApos.begin() + nLvl> can be performed.
5643*b1cdbd2cSJim Jagielski if ( sal::static_int_cast< sal_Int32>(nLvl) >= sal::static_int_cast< sal_Int32>(maApos.size()) )
5644*b1cdbd2cSJim Jagielski {
5645*b1cdbd2cSJim Jagielski return false;
5646*b1cdbd2cSJim Jagielski }
5647*b1cdbd2cSJim Jagielski mycApoIter aIter = std::find(maApos.begin() + nLvl, maApos.end(), true);
5648*b1cdbd2cSJim Jagielski if (aIter != maApos.end())
5649*b1cdbd2cSJim Jagielski return true;
5650*b1cdbd2cSJim Jagielski else
5651*b1cdbd2cSJim Jagielski return false;
5652*b1cdbd2cSJim Jagielski }
5653*b1cdbd2cSJim Jagielski
InEqualApo(int nLvl) const5654*b1cdbd2cSJim Jagielski bool SwWW8ImplReader::InEqualApo(int nLvl) const
5655*b1cdbd2cSJim Jagielski {
5656*b1cdbd2cSJim Jagielski //If we are in a table, see if an apo was inserted at the level below
5657*b1cdbd2cSJim Jagielski //the table.
5658*b1cdbd2cSJim Jagielski if (nLvl)
5659*b1cdbd2cSJim Jagielski --nLvl;
5660*b1cdbd2cSJim Jagielski return maApos[nLvl];
5661*b1cdbd2cSJim Jagielski }
5662*b1cdbd2cSJim Jagielski
5663*b1cdbd2cSJim Jagielski namespace sw
5664*b1cdbd2cSJim Jagielski {
5665*b1cdbd2cSJim Jagielski namespace hack
5666*b1cdbd2cSJim Jagielski {
Position(const SwPosition & rPos)5667*b1cdbd2cSJim Jagielski Position::Position(const SwPosition &rPos)
5668*b1cdbd2cSJim Jagielski : maPtNode(rPos.nNode), mnPtCntnt(rPos.nContent.GetIndex())
5669*b1cdbd2cSJim Jagielski {
5670*b1cdbd2cSJim Jagielski }
5671*b1cdbd2cSJim Jagielski
Position(const Position & rPos)5672*b1cdbd2cSJim Jagielski Position::Position(const Position &rPos)
5673*b1cdbd2cSJim Jagielski : maPtNode(rPos.maPtNode), mnPtCntnt(rPos.mnPtCntnt)
5674*b1cdbd2cSJim Jagielski {
5675*b1cdbd2cSJim Jagielski }
5676*b1cdbd2cSJim Jagielski
operator SwPosition() const5677*b1cdbd2cSJim Jagielski Position::operator SwPosition() const
5678*b1cdbd2cSJim Jagielski {
5679*b1cdbd2cSJim Jagielski SwPosition aRet(maPtNode);
5680*b1cdbd2cSJim Jagielski aRet.nContent.Assign(maPtNode.GetNode().GetCntntNode(), mnPtCntnt);
5681*b1cdbd2cSJim Jagielski return aRet;
5682*b1cdbd2cSJim Jagielski }
5683*b1cdbd2cSJim Jagielski }
5684*b1cdbd2cSJim Jagielski }
5685*b1cdbd2cSJim Jagielski
5686*b1cdbd2cSJim Jagielski /* vi:set tabstop=4 shiftwidth=4 expandtab: */
5687*b1cdbd2cSJim Jagielski
SwMacroInfo()5688*b1cdbd2cSJim Jagielski SwMacroInfo::SwMacroInfo() :
5689*b1cdbd2cSJim Jagielski SdrObjUserData( SW_DRAWLAYER, SW_UD_IMAPDATA, 0 )
5690*b1cdbd2cSJim Jagielski {
5691*b1cdbd2cSJim Jagielski }
5692*b1cdbd2cSJim Jagielski
~SwMacroInfo()5693*b1cdbd2cSJim Jagielski SwMacroInfo::~SwMacroInfo()
5694*b1cdbd2cSJim Jagielski {
5695*b1cdbd2cSJim Jagielski }
5696*b1cdbd2cSJim Jagielski
Clone(SdrObject *) const5697*b1cdbd2cSJim Jagielski SdrObjUserData* SwMacroInfo::Clone( SdrObject* /*pObj*/ ) const
5698*b1cdbd2cSJim Jagielski {
5699*b1cdbd2cSJim Jagielski return new SwMacroInfo( *this );
5700*b1cdbd2cSJim Jagielski }
5701*b1cdbd2cSJim Jagielski
5702*b1cdbd2cSJim Jagielski
5703*b1cdbd2cSJim Jagielski
5704