xref: /aoo42x/main/sw/source/filter/ww1/w1class.cxx (revision efeef26f)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 
27 
28 #include <string.h>
29 #include <tools/stream.hxx>
30 
31 #ifndef _W1CLASS_HXX
32 #include <w1class.hxx>
33 #endif
34 
35 
36 #ifdef DUMP
37 static const sal_Char* pUnknown = "?";
38 #define DUMPNAME(s) s
39 #else
40 #define DUMPNAME(s) 0
41 #endif
42 
43 Ww1SingleSprm* Ww1Sprm::aTab[ 256 ];
44 Ww1SingleSprm* Ww1Sprm::pSingleSprm = 0;
45 
46 
47 
48 /////////////////////////////////////////////////////////////////// Fib
Ww1Fib(SvStream & _rStream)49 Ww1Fib::Ww1Fib( SvStream& _rStream )
50 	: rStream(_rStream)
51 {
52 	bOK = 0 == rStream.Seek(0) &&
53 		  rStream.Read( &aFib, sizeof( aFib )) == sizeof( aFib );
54 }
55 
56 ///////////////////////////////////////////////////////////// PlainText
57 
Ww1PlainText(Ww1Fib & rWwFib,sal_uLong nFilePos,sal_uLong nCountBytes)58 Ww1PlainText::Ww1PlainText(Ww1Fib& rWwFib, sal_uLong nFilePos, sal_uLong nCountBytes)
59     : rFib(rWwFib), ulFilePos(nFilePos), ulCountBytes(nCountBytes),
60     ulSeek(0), bOK(true)
61 {
62 }
63 
operator [](sal_uLong ulOffset)64 sal_Unicode Ww1PlainText::operator [] ( sal_uLong ulOffset )
65 {
66 	DBG_ASSERT( ulOffset<Count(), "Ww1PlainText" );
67 	sal_Unicode cRet;
68 	sal_Char cRead;
69 	if( rFib.GetStream().Seek( ulFilePos + ulOffset ) == ulFilePos+ulOffset &&
70 		rFib.GetStream().Read( &cRead, sizeof( cRead ) ) == sizeof( cRead ) )
71 	{
72 		cRet = ByteString::ConvertToUnicode( cRead, RTL_TEXTENCODING_MS_1252 );
73 	}
74 	else
75 		cRet = ' ';
76 	return cRet;
77 }
78 
GetText(sal_uLong ulOffset,sal_uLong nLen) const79 String Ww1PlainText::GetText( sal_uLong ulOffset, sal_uLong nLen ) const
80 {
81 	String sRet;
82 	ByteString aStr;
83 	DBG_ASSERT(ulOffset+nLen<Count(), "Ww1PlainText");
84 	if( rFib.GetStream().Seek(ulFilePos+ulOffset) == ulFilePos+ulOffset &&
85         rFib.GetStream().Read( aStr.AllocBuffer( static_cast< xub_StrLen >(nLen) ), nLen ) == nLen )
86 		sRet = String( aStr, RTL_TEXTENCODING_MS_1252 );
87 	return sRet;
88 }
89 
90 ///////////////////////////////////////////////////////////////// Style
Ww1Style()91 Ww1Style::Ww1Style()
92 	: pPapx(0), pParent(0), stcBase(0), stcNext(0), bUsed(false)
93 {
94 }
95 
~Ww1Style()96 Ww1Style::~Ww1Style()
97 {
98 	delete pPapx;
99 }
100 
SetDefaults(sal_uInt8 stc)101 void Ww1Style::SetDefaults(sal_uInt8 stc)
102 {
103 	if( 222 == stc )
104 	{
105 		stcBase = 222;
106 		stcNext = 222;
107 		aChpx.hpsSet(20);
108 	}
109 }
110 
ReadName(sal_uInt8 * & p,sal_uInt16 & rnCountBytes,sal_uInt16 stc)111 sal_uInt16 Ww1Style::ReadName( sal_uInt8*&p, sal_uInt16& rnCountBytes, sal_uInt16 stc )
112 {
113 	sal_uInt8 nCountBytes = SVBT8ToByte(p);
114 	p++;
115 	rnCountBytes--;
116 	if( !nCountBytes ) // default
117 	{
118 		static const sal_Char* __READONLY_DATA names[] =
119 		{
120 			"W1 Null",  //222
121 			"W1 Annotation reference",  //223
122 			"W1 Annotation text",  //224
123 			"W1 Table of contents 8",  //225
124 			"W1 Table of contents 7",  //226
125 			"W1 Table of contents 6",  //227
126 			"W1 Table of contents 5",  //228
127 			"W1 Table of contents 4",  //229
128 			"W1 Table of contents 3",  //230
129 			"W1 Table of contents 2",  //231
130 			"W1 Table of contents 1",  //232
131 			"W1 Index 7",  //233
132 			"W1 Index 6",  //234
133 			"W1 Index 5",  //235
134 			"W1 Index 4",  //236
135 			"W1 Index 3",  //237
136 			"W1 Index 2",  //238
137 			"W1 Index 1",  //239
138 			"W1 Line number",  //240
139 			"W1 Index heading",  //241
140 			"W1 Footer",  //242
141 			"W1 Header",  //243
142 			"W1 Footnote reference",  //244
143 			"W1 Footnote text",  //245
144 			"W1 Heading 9",  //246
145 			"W1 Heading 8",  //247
146 			"W1 Heading 7",  //248
147 			"W1 Heading 6",  //249
148 			"W1 Heading 5",  //250
149 			"W1 Heading 4",  //251
150 			"W1 Heading 3",  //252
151 			"W1 Heading 2",  //253
152 			"W1 Heading 1",  //254
153 			"W1 Normal indent"  //255
154 			};//256
155 
156 		const sal_Char* pStr;
157 		size_t nSize(stc);
158 		if (!nSize)
159 			pStr = "W1 Normal";
160 		else if (nSize - 222 >= sizeof(names) / sizeof(*names))
161 			pStr = "?";
162 		else
163 			pStr = names[nSize-222];
164 		SetName(String(pStr, RTL_TEXTENCODING_MS_1252));
165 	}
166 	else if( 255 > nCountBytes ) // unused
167 	{
168 		SetName( String( (sal_Char*)p, nCountBytes, RTL_TEXTENCODING_MS_1252 ));
169 		p += nCountBytes;
170 		DBG_ASSERT(rnCountBytes>=nCountBytes, "Ww1Style");
171         rnCountBytes = rnCountBytes - nCountBytes;
172 	}
173 	return 0;
174 }
175 
ReadChpx(sal_uInt8 * & p,sal_uInt16 & rnCountBytes)176 sal_uInt16 Ww1Style::ReadChpx( sal_uInt8*&p, sal_uInt16& rnCountBytes )
177 {
178 	sal_uInt16 nCountBytes = SVBT8ToByte(p);
179 	p++;
180 	rnCountBytes--;
181 	if (nCountBytes != 255 // unused
182 	 && nCountBytes != 0) // default
183 	{
184 		if (nCountBytes > sizeof(aChpx))
185 			nCountBytes = sizeof(aChpx);
186 		memcpy( &aChpx, p, nCountBytes );
187 		p += nCountBytes;
188 		DBG_ASSERT(rnCountBytes>=nCountBytes, "Ww1Style");
189         rnCountBytes = rnCountBytes - nCountBytes;
190 	}
191 	return 0;
192 }
193 
ReadPapx(sal_uInt8 * & p,sal_uInt16 & rnCountBytes)194 sal_uInt16 Ww1Style::ReadPapx(sal_uInt8*&p, sal_uInt16& rnCountBytes)
195 {
196 	sal_uInt16 nCountBytes = SVBT8ToByte(p);
197 	p++;
198 	rnCountBytes--;
199 	if (nCountBytes != 255)
200 	{
201 		pPapx = new Ww1SprmPapx(p, nCountBytes);
202 		p += nCountBytes;
203 		DBG_ASSERT(rnCountBytes>=nCountBytes, "Ww1Style");
204         rnCountBytes = rnCountBytes - nCountBytes;
205 	}
206 	else
207 		pPapx = new Ww1SprmPapx(p, 0);
208 	return 0;
209 }
210 
ReadEstcp(sal_uInt8 * & p,sal_uInt16 & rnCountBytes)211 sal_uInt16 Ww1Style::ReadEstcp(sal_uInt8*&p, sal_uInt16& rnCountBytes)
212 {
213 	stcNext = SVBT8ToByte(p);
214 	p++;
215 	rnCountBytes--;
216 	stcBase = SVBT8ToByte(p);
217 	p++;
218 	DBG_ASSERT(rnCountBytes>0, "Ww1Style");
219 	rnCountBytes--;
220 	return 0;
221 }
222 
223 //////////////////////////////////////////////////////////// StyleSheet
Ww1StyleSheet(Ww1Fib & _rFib)224 Ww1StyleSheet::Ww1StyleSheet(Ww1Fib& _rFib)
225 	: cstcStd(0),
226 	rFib(_rFib),
227 	bOK(sal_False)
228 {
229 	sal_uInt16 cbStshf = rFib.GetFIB().cbStshfGet();
230 	DBG_ASSERT(cbStshf>=17, "Ww1StyleSheet");
231 	for (sal_uInt16 stc=0;stc<Count();stc++)
232 	{
233 		aStyles[stc].SetParent(this);
234 		aStyles[stc].SetDefaults((sal_uInt8)stc);
235 	}
236 	sal_uInt8* del = NULL;
237 	if (rFib.GetStream().Seek(rFib.GetFIB().fcStshfGet())
238 	  == (sal_uLong)rFib.GetFIB().fcStshfGet()
239 	 && (del = new sal_uInt8[cbStshf]) != NULL
240 	 && rFib.GetStream().Read(del, cbStshf) == (sal_uLong)cbStshf)
241 		{
242 		sal_uInt8* p = del;
243 			cstcStd = SVBT16ToShort(p);
244 			p += sizeof(SVBT16);
245 			cbStshf -= sizeof(SVBT16);
246 			ReadNames(p, cbStshf);
247 			ReadChpx(p, cbStshf);
248 			ReadPapx(p, cbStshf);
249 			ReadEstcp(p, cbStshf);
250 			DBG_ASSERT(cbStshf==0, "Ww1StyleSheet");
251 			bOK = cbStshf == 0;
252 		}
253 	delete [] del;
254 }
255 
ReadNames(sal_uInt8 * & p,sal_uInt16 & rnCountBytes)256 sal_uInt16 Ww1StyleSheet::ReadNames( sal_uInt8*& p, sal_uInt16& rnCountBytes )
257 {
258 	sal_uInt16 nCountBytes = SVBT16ToShort(p);
259 	p += sizeof(SVBT16);
260 	DBG_ASSERT(rnCountBytes>=nCountBytes, "Ww1StyleSheet");
261     rnCountBytes = rnCountBytes - nCountBytes;
262     nCountBytes = nCountBytes - sizeof(SVBT16);
263 	sal_uInt16 stcp = 0;
264 	while (nCountBytes > 0)
265 	{
266 		sal_uInt16 stc = (stcp - cstcStd) & 255;
267 		aStyles[stc].ReadName(p, nCountBytes, stc);
268 		stcp++;
269 	}
270 	DBG_ASSERT(nCountBytes==0, "Ww1StyleSheet");
271 	return 0;
272 }
273 
ReadChpx(sal_uInt8 * & p,sal_uInt16 & rnCountBytes)274 sal_uInt16 Ww1StyleSheet::ReadChpx(sal_uInt8*& p, sal_uInt16& rnCountBytes)
275 {
276 	sal_uInt16 nCountBytes = SVBT16ToShort(p);
277 	p += sizeof(SVBT16);
278 	DBG_ASSERT(rnCountBytes>=nCountBytes, "Ww1StyleSheet");
279     rnCountBytes = rnCountBytes - nCountBytes;
280     nCountBytes = nCountBytes - sizeof(SVBT16);
281 	sal_uInt16 stcp = 0;
282 	while (nCountBytes > 0)
283 	{
284 		sal_uInt16 stc = (stcp - cstcStd) & 255;
285 		aStyles[stc].ReadChpx(p, nCountBytes);
286 		stcp++;
287 	}
288 	DBG_ASSERT(nCountBytes == 0, "Ww1StyleSheet");
289 	return 0;
290 }
291 
ReadPapx(sal_uInt8 * & p,sal_uInt16 & rnCountBytes)292 sal_uInt16 Ww1StyleSheet::ReadPapx(sal_uInt8*& p, sal_uInt16& rnCountBytes)
293 {
294 	sal_uInt16 nCountBytes = SVBT16ToShort(p);
295 	p += sizeof(SVBT16);
296 	DBG_ASSERT(rnCountBytes>=nCountBytes, "Ww1StyleSheet");
297     rnCountBytes = rnCountBytes - nCountBytes;
298     nCountBytes = nCountBytes - sizeof(SVBT16);
299 	sal_uInt16 stcp = 0;
300 	while (nCountBytes > 0)
301 	{
302 		sal_uInt16 stc = (stcp - cstcStd) & 255;
303 		aStyles[stc].ReadPapx(p, nCountBytes);
304 		stcp++;
305 	}
306 	DBG_ASSERT(nCountBytes == 0, "Ww1StyleSheet");
307 	return 0;
308 }
309 
ReadEstcp(sal_uInt8 * & p,sal_uInt16 & rnCountBytes)310 sal_uInt16 Ww1StyleSheet::ReadEstcp(sal_uInt8*& p, sal_uInt16& rnCountBytes)
311 {
312 	sal_uInt16 iMac = SVBT16ToShort(p);
313 	p += sizeof(SVBT16);
314 	DBG_ASSERT(rnCountBytes>=sizeof(SVBT16), "Ww1StyleSheet");
315 	rnCountBytes -= sizeof(SVBT16);
316 	for (sal_uInt16 stcp=0;stcp<iMac;stcp++)
317 	{
318 		sal_uInt16 stc = (stcp - cstcStd) & 255;
319 		aStyles[stc].ReadEstcp(p, rnCountBytes);
320 	}
321 	DBG_ASSERT(rnCountBytes==0, "Ww1StyleSheet");
322 	return 0;
323 }
324 
325 ///////////////////////////////////////////////////////////////// Fonts
326 
Ww1Fonts(Ww1Fib & rInFib,sal_uLong nFieldFlgs)327 Ww1Fonts::Ww1Fonts(Ww1Fib& rInFib, sal_uLong nFieldFlgs)
328 	: pFontA(0), rFib(rInFib), nFieldFlags(nFieldFlgs), nMax(0), bOK(false)
329 {
330 	if(rFib.GetFIB().cbSttbfffnGet() > 2 ) // ueberhaupt fonts?
331 	{
332 		SVBT16 nCountBytes;
333 		DBG_ASSERT(rFib.GetFIB().cbSttbfffnGet() > sizeof(nCountBytes), "Ww1Fonts");
334 		if (rFib.GetStream().Seek(rFib.GetFIB().fcSttbfffnGet())
335 		 == (sal_uLong)rFib.GetFIB().fcSttbfffnGet())
336 			if (rFib.GetStream().Read(nCountBytes, sizeof(nCountBytes))
337 			 == sizeof(nCountBytes)) // Laenge steht hier nochmal
338 			{
339 				DBG_ASSERT(SVBT16ToShort(nCountBytes)
340 				 == rFib.GetFIB().cbSttbfffnGet(), "redundant-size missmatch");
341 				 // hoffentlich sind sie immer gleich
342 				W1_FFN* pA = (W1_FFN*)new char[rFib.GetFIB().cbSttbfffnGet()
343 				 - sizeof(nCountBytes)]; // Alloziere Font-Array
344 				//~ Ww1: new-NULL
345 				if (rFib.GetStream().Read(pA, rFib.GetFIB().cbSttbfffnGet()
346 				 - sizeof(nCountBytes)) == (sal_uLong)rFib.GetFIB().cbSttbfffnGet()
347 				 - sizeof(nCountBytes))	// lese alle Fonts
348 				{} //nothing
349 
350 				long nLeft = rFib.GetFIB().cbSttbfffnGet()
351 				 - sizeof(nCountBytes); // Zaehle, wieviele Fonts enthalten
352 				W1_FFN* p = pA;
353 				while (1)
354 				{
355 					sal_uInt16 nNextSiz;
356 					nNextSiz = p->cbFfnM1Get() + 1;
357 					if(nNextSiz > nLeft)
358 						break;
359 					nMax++;
360 					nLeft -= nNextSiz;
361 					if(nLeft < 1)			// naechste Laenge muss gelesen werden koennen
362 						break;
363 					p = (W1_FFN *)(((char*)p) + nNextSiz);
364 				}
365 				if (nMax)
366 				{
367 					pFontA = new W1_FFN*[nMax];			// alloziere Index-Array
368 					//~ Ww1: new-NULL
369 					pFontA[0] = pA;						// fuelle Index-Array
370 					sal_uInt16 i;
371 					for(i=1, p=pA; i<nMax; i++)
372 					{
373 						p = (W1_FFN*)(((char*)p) + p->cbFfnM1Get() + 1);
374 						pFontA[i] = p;
375 					}
376 				}
377 				else
378 					pFontA = 0;	// Keine Eintraege -> kein Array
379 			}
380 	}
381 	bOK = sal_True;
382 }
383 
GetFFN(sal_uInt16 nNum)384 W1_FFN* Ww1Fonts::GetFFN(sal_uInt16 nNum)
385 {
386 	W1_FFN* pRet = NULL;
387 	if (pFontA)
388 		if (nNum < nMax)
389 			pRet = pFontA[nNum];
390 	return pRet;
391 }
392 
393 /////////////////////////////////////////////////////////////////// DOP
Ww1Dop(Ww1Fib & _rFib)394 Ww1Dop::Ww1Dop(Ww1Fib& _rFib)
395 	: rFib(_rFib)
396 {
397 	long nRead;
398 	memset(&aDop, 0, sizeof(aDop)); // set defaults
399 	if(rFib.GetFIB().cbDopGet() >= sizeof(aDop))
400 		nRead = sizeof(aDop);
401 	else
402 		nRead = rFib.GetFIB().cbDopGet();
403 	bOK = rFib.GetStream().Seek(rFib.GetFIB().fcDopGet()) ==
404 				(sal_uLong)rFib.GetFIB().fcDopGet() &&
405 			rFib.GetStream().Read(&aDop, nRead) == (sal_uLong)nRead;
406 }
407 
408 /////////////////////////////////////////////////////////////// Picture
Ww1Picture(SvStream & rStream,sal_uLong ulFilePos)409 Ww1Picture::Ww1Picture(SvStream& rStream, sal_uLong ulFilePos)
410 	: bOK(false), pPic(0)
411 {
412 	ulFilePos &= 0xffffff; //~ ww1: warum auch immer - im highbyte steht eine 5?!?!
413 	SVBT32 lcb;
414 	if (rStream.Seek(ulFilePos) == (sal_uLong)ulFilePos)
415 		if (rStream.Read(&lcb, sizeof(lcb)) == (sal_uLong)sizeof(lcb))
416 			if (sizeof(int)>=4 || SVBT32ToUInt32(lcb) < 0x8000) //~ mdt: 64K & 16bit
417 				if ((pPic = (W1_PIC*)(new sal_uInt8[SVBT32ToUInt32(lcb)])) != NULL)
418 					if (rStream.Seek(ulFilePos) == (sal_uLong)ulFilePos)
419 						if (rStream.Read(pPic, SVBT32ToUInt32(lcb)) == (sal_uLong)SVBT32ToUInt32(lcb))
420 						{
421 							DBG_ASSERT(pPic->cbHeaderGet()==sizeof(*pPic)-sizeof(pPic->rgb), "Ww1Picture");
422 							bOK = true;
423 						}
424 }
425 
426 ////////////////////////////////////////////////////////////////// Sprm
Ww1Sprm(sal_uInt8 * x,sal_uInt16 _nCountBytes)427 Ww1Sprm::Ww1Sprm(sal_uInt8* x, sal_uInt16 _nCountBytes)
428 	: p(NULL),
429 	nCountBytes(_nCountBytes),
430 	bOK(sal_False),
431 	pArr(NULL),
432 	count(0)
433 {
434 	if (nCountBytes == 0)
435 		bOK = sal_True;
436 	else
437 		if ((p = new sal_uInt8[nCountBytes]) != NULL)
438 		{
439 			memcpy(p, x, nCountBytes);
440 			if (ReCalc())
441 				bOK = sal_True;
442 		}
443 }
444 
Ww1Sprm(SvStream & rStream,sal_uLong ulFilePos)445 Ww1Sprm::Ww1Sprm(SvStream& rStream, sal_uLong ulFilePos)
446 	: p(NULL),
447 	nCountBytes(0),
448 	bOK(sal_False),
449 	pArr(NULL),
450 	count(0)
451 {
452 	SVBT8 x;
453 	ByteToSVBT8(0, x);
454 	if (rStream.Seek(ulFilePos) == (sal_uLong)ulFilePos)
455 		if (rStream.Read(&x, sizeof(x)) == (sal_uLong)sizeof(x))
456 			if ((nCountBytes = SVBT8ToByte(x)) == 255
457 			 || !nCountBytes
458 			 || (p = new sal_uInt8[nCountBytes]) != NULL)
459 				if (nCountBytes == 255
460 				 || !nCountBytes
461 				 || rStream.Read(p, nCountBytes) == (sal_uLong)nCountBytes)
462 					if (ReCalc())
463 						bOK = sal_True;
464 }
465 
~Ww1Sprm()466 Ww1Sprm::~Ww1Sprm()
467 {
468 	delete pArr;
469 	delete p;
470 }
471 
Size(sal_uInt8 *)472 sal_uInt16 Ww1SingleSprm::Size(sal_uInt8* /*pSprm*/)
473 {
474 	return nCountBytes;
475 }
476 
Size(sal_uInt8 * pSprm)477 sal_uInt16 Ww1SingleSprmTab::Size(sal_uInt8* pSprm) // Doc 24/25, Fastsave-Sprm
478 {
479 	DBG_ASSERT(nCountBytes==0, "Ww1SingleSprmTab");
480 	sal_uInt16 nRet = sizeof(SVBT8);
481 	sal_uInt16 nSize = SVBT8ToByte(pSprm);
482 	if (nSize != 255)
483         nRet = nRet + nSize;
484 	else
485 	{
486 		sal_uInt16 nDel = SVBT8ToByte(pSprm+1) * 4;
487 		sal_uInt16 nIns = SVBT8ToByte(pSprm + 3 + nDel) * 3;
488 		nRet += nDel + nIns;
489 	}
490 	DBG_ASSERT(nRet <= 354, "Ww1SingleSprmTab");
491 	if (nRet > 354)
492 		nRet = 0;
493 	return nRet;
494 }
495 
Size(sal_uInt8 * pSprm)496 sal_uInt16 Ww1SingleSprmByteSized::Size(sal_uInt8* pSprm)
497 {
498 	sal_uInt16 nRet;
499 	nRet = SVBT8ToByte(pSprm);
500 	nRet += sizeof(SVBT8);	// var. l. byte-size
501 //	pSprm += sizeof(SVBT8); // var. l. byte-size
502     nRet = nRet + nCountBytes;
503 	return nRet;
504 }
505 
Size(sal_uInt8 * pSprm)506 sal_uInt16 Ww1SingleSprmWordSized::Size(sal_uInt8* pSprm)
507 {
508 	sal_uInt16 nRet;
509 	nRet = SVBT16ToShort(pSprm);
510 	nRet += sizeof(SVBT16);  // var. l. word-size
511 //	pSprm += sizeof(SVBT16); // var. l. word-size
512     nRet = nRet + nCountBytes;
513 	return nRet;
514 }
515 
516 static sal_uInt8 nLast = 0;
517 static sal_uInt8 nCurrent = 0;
GetSize(sal_uInt8 nId,sal_uInt8 * pSprm)518 sal_uInt16 Ww1Sprm::GetSize(sal_uInt8 nId, sal_uInt8* pSprm)
519 {
520 	//DBG_ASSERT( nId < sizeof(aTab) / sizeof(*aTab), "Ww1Sprm" );
521 	sal_uInt16 nL = 0;
522 	nL = GetTab(nId).Size(pSprm);
523 	nLast = nCurrent;
524 	nCurrent = nId;
525 	return nL;
526 }
527 
Fill(sal_uInt16 index,sal_uInt8 & nId,sal_uInt16 & nL,sal_uInt8 * & pSprm)528 sal_Bool Ww1Sprm::Fill(sal_uInt16 index, sal_uInt8& nId, sal_uInt16& nL, sal_uInt8*& pSprm)
529 {
530 	//DBG_ASSERT( nId < sizeof(aTab) / sizeof(*aTab), "Ww1Sprm");
531 	DBG_ASSERT(index < Count(), "Ww1Sprm");
532 	pSprm = p + pArr[index];
533 	nId = SVBT8ToByte(pSprm);
534 	pSprm++;
535 	nL = GetTab(nId).Size(pSprm);
536 	return sal_True;
537 }
538 
ReCalc()539 sal_Bool Ww1Sprm::ReCalc()
540 {
541 	sal_Bool bRet = sal_True;
542 	delete pArr;
543 	pArr = NULL;
544 	count = 0;
545 	if (nCountBytes != 255) // not unused?
546 	{
547 		sal_uInt16 cbsik = nCountBytes;
548 		sal_uInt8* psik = p;
549 		while (cbsik > 0)
550 		{
551 			sal_uInt16 iLen = GetSizeBrutto(psik);
552 			DBG_ASSERT(iLen<=cbsik, "Ww1Sprm");
553 			if (iLen > cbsik)
554 				cbsik = 0; // ignore the rest: we are wrong...
555 			else
556 			{
557 				psik += iLen;
558                 cbsik = cbsik - iLen;
559 				count++;
560 			}
561 		}
562 		if (bRet
563 		 && (pArr = new sal_uInt16[count]) != NULL)
564 		{
565 			cbsik = nCountBytes;
566 			sal_uInt16 offset = 0;
567 			sal_uInt16 current = 0;
568 			psik = p;
569 			while (current<count)
570 			{
571 				pArr[current++] = offset;
572 				sal_uInt16 iLen = GetSizeBrutto(psik);
573 				psik += iLen;
574 				if (iLen > cbsik)
575 					cbsik = 0;
576 				else
577                     cbsik = cbsik - iLen;
578                 offset = offset + iLen;
579 			}
580 
581 		}
582 		else
583 			count = 0;
584 	}
585 	return bRet;
586 }
587 
DeinitTab()588 void Ww1Sprm::DeinitTab()
589 {
590 	for (size_t i=0; i < sizeof(aTab)/sizeof(*aTab); ++i)
591 		delete aTab[i];
592 	memset(aTab, 0, sizeof(aTab)/sizeof(*aTab));
593 	delete pSingleSprm;
594 }
595 
InitTab()596 void Ww1Sprm::InitTab()
597 {
598 	memset(aTab, 0, sizeof(aTab)/sizeof(*aTab));
599 	pSingleSprm = new Ww1SingleSprm( 0, DUMPNAME(pUnknown));
600 
601 	aTab[  2] = new Ww1SingleSprmByte(DUMPNAME("sprmPStc")); //   2 pap.istd (style code)
602 	aTab[  3] = new Ww1SingleSprmByteSized(0, DUMPNAME("sprmPIstdPermute")); //   3 pap.istd	permutation
603 	aTab[  4] = new Ww1SingleSprmByte(DUMPNAME("sprmPIncLevel")); //   4 pap.istddifference
604 	aTab[  5] = new Ww1SingleSprmPJc(DUMPNAME("sprmPJc")); //   5 pap.jc (justification)
605 	aTab[  6] = new Ww1SingleSprmBool(DUMPNAME("sprmPFSideBySide")); //   6 pap.fSideBySide
606 	aTab[  7] = new Ww1SingleSprmPFKeep(DUMPNAME("sprmPFKeep")); //   7 pap.fKeep
607 	aTab[  8] = new Ww1SingleSprmPFKeepFollow(DUMPNAME("sprmPFKeepFollow")); //   8 pap.fKeepFollow
608 	aTab[  9] = new Ww1SingleSprmPPageBreakBefore(DUMPNAME("sprmPPageBreakBefore")); //   9 pap.fPageBreakBefore
609 	aTab[ 10] = new Ww1SingleSprmByte(DUMPNAME("sprmPBrcl")); //  10 pap.brcl
610 	aTab[ 11] = new Ww1SingleSprmByte(DUMPNAME("sprmPBrcp")); //  11 pap.brcp
611 	aTab[ 12] = new Ww1SingleSprmByteSized(0, DUMPNAME("sprmPAnld")); //  12 pap.anld (ANLD structure)
612 	aTab[ 13] = new Ww1SingleSprmByte(DUMPNAME("sprmPNLvlAnm")); //  13 pap.nLvlAnm nn
613 	aTab[ 14] = new Ww1SingleSprmBool(DUMPNAME("sprmPFNoLineNumb")); //  14 ap.fNoLnn
614 	aTab[ 15] = new Ww1SingleSprmPChgTabsPapx(DUMPNAME("sprmPChgTabsPapx")); //  15 pap.itbdMac, ...
615 	aTab[ 16] = new Ww1SingleSprmPDxaRight(DUMPNAME("sprmPDxaRight")); //  16 pap.dxaRight
616 	aTab[ 17] = new Ww1SingleSprmPDxaLeft(DUMPNAME("sprmPDxaLeft")); //  17 pap.dxaLeft
617 	aTab[ 18] = new Ww1SingleSprmWord(DUMPNAME("sprmPNest")); //  18 pap.dxaNest
618 	aTab[ 19] = new Ww1SingleSprmPDxaLeft1(DUMPNAME("sprmPDxaLeft1")); //  19 pap.dxaLeft1
619 	aTab[ 20] = new Ww1SingleSprmPDyaLine(DUMPNAME("sprmPDyaLine")); //  20 pap.lspd	an LSPD
620 	aTab[ 21] = new Ww1SingleSprmPDyaBefore(DUMPNAME("sprmPDyaBefore")); //  21 pap.dyaBefore
621 	aTab[ 22] = new Ww1SingleSprmPDyaAfter(DUMPNAME("sprmPDyaAfter")); //  22 pap.dyaAfter
622 	aTab[ 23] = new Ww1SingleSprmTab(0, DUMPNAME(pUnknown)); // 23 pap.itbdMac, pap.rgdxaTab
623 	aTab[ 24] = new Ww1SingleSprmPFInTable(DUMPNAME("sprmPFInTable")); //  24 pap.fInTable
624 	aTab[ 25] = new Ww1SingleSprmPTtp(DUMPNAME("sprmPTtp")); //  25 pap.fTtp
625 	aTab[ 26] = new Ww1SingleSprmPDxaAbs(DUMPNAME("sprmPDxaAbs")); //  26 pap.dxaAbs
626 	aTab[ 27] = new Ww1SingleSprmPDyaAbs(DUMPNAME("sprmPDyaAbs")); //  27 pap.dyaAbs
627 	aTab[ 28] = new Ww1SingleSprmPDxaWidth(DUMPNAME("sprmPDxaWidth")); //  28 pap.dxaWidth
628 	aTab[ 29] = new Ww1SingleSprmPpc(DUMPNAME("sprmPPc")); //  29 pap.pcHorz, pap.pcVert
629 	aTab[ 30] = new Ww1SingleSprmPBrc10(BRC_TOP, DUMPNAME("sprmPBrcTop10")); //  30 pap.brcTop BRC10
630 	aTab[ 31] = new Ww1SingleSprmPBrc10(BRC_LEFT, DUMPNAME("sprmPBrcLeft10")); //  31 pap.brcLeft BRC10
631 	aTab[ 32] = new Ww1SingleSprmPBrc10(BRC_BOTTOM, DUMPNAME("sprmPBrcBottom10")); //  32 pap.brcBottom BRC10
632 	aTab[ 33] = new Ww1SingleSprmPBrc10(BRC_RIGHT, DUMPNAME("sprmPBrcRight10")); //  33 pap.brcRight BRC10
633 	aTab[ 34] = new Ww1SingleSprmWord(DUMPNAME("sprmPBrcBetween10")); //  34 pap.brcBetween BRC10
634 	aTab[ 35] = new Ww1SingleSprmPBrc10(BRC_LEFT, DUMPNAME("sprmPBrcBar10")); //  35 pap.brcBar BRC10
635 	aTab[ 36] = new Ww1SingleSprmPFromText(DUMPNAME("sprmPFromText10")); //  36 pap.dxaFromText dxa
636 	aTab[ 37] = new Ww1SingleSprmByte(DUMPNAME("sprmPWr")); //  37 pap.wr wr
637 	aTab[ 38] = new Ww1SingleSprmWord(DUMPNAME("sprmPBrcTop")); //  38 pap.brcTop BRC
638 	aTab[ 39] = new Ww1SingleSprmWord(DUMPNAME("sprmPBrcLeft")); //  39 pap.brcLeft BRC
639 	aTab[ 40] = new Ww1SingleSprmWord(DUMPNAME("sprmPBrcBottom")); //  40 pap.brcBottom BRC
640 	aTab[ 41] = new Ww1SingleSprmWord(DUMPNAME("sprmPBrcRight")); //  41 pap.brcRight BRC
641 	aTab[ 42] = new Ww1SingleSprmWord(DUMPNAME("sprmPBrcBetween")); //  42 pap.brcBetween BRC
642 	aTab[ 43] = new Ww1SingleSprmWord(DUMPNAME("sprmPBrcBar")); //  43 pap.brcBar BRC word
643 	aTab[ 44] = new Ww1SingleSprmBool(DUMPNAME("sprmPFNoAutoHyph")); //  44 pap.fNoAutoHyph
644 	aTab[ 45] = new Ww1SingleSprmWord(DUMPNAME("sprmPWHeightAbs")); //  45 pap.wHeightAbs w
645 	aTab[ 46] = new Ww1SingleSprmWord(DUMPNAME("sprmPDcs")); //  46 pap.dcs DCS
646 	aTab[ 47] = new Ww1SingleSprmWord(DUMPNAME("sprmPShd")); //  47 pap.shd SHD
647 	aTab[ 48] = new Ww1SingleSprmWord(DUMPNAME("sprmPDyaFromText")); //  48 pap.dyaFromText dya
648 	aTab[ 49] = new Ww1SingleSprmWord(DUMPNAME("sprmPDxaFromText")); //  49 pap.dxaFromText dxa
649 	aTab[ 50] = new Ww1SingleSprmBool(DUMPNAME("sprmPFLocked")); //  50 pap.fLocked 0 or 1 byte
650 	aTab[ 51] = new Ww1SingleSprmBool(DUMPNAME("sprmPFWidowControl")); //  51 pap.fWidowControl 0 or 1 byte
651 
652 	aTab[ 57] = new Ww1SingleSprmByteSized(0, DUMPNAME("sprmCDefault")); //  57 whole CHP (see below) none variable length
653 	aTab[ 58] = new Ww1SingleSprm(0, DUMPNAME("sprmCPlain")); //  58 whole CHP (see below) none 0
654 
655 	aTab[ 60] = new Ww1SingleSprm4State(DUMPNAME("sprmCFBold")); //  60 chp.fBold 0,1, 128, or 129 (see below) byte
656 	aTab[ 61] = new Ww1SingleSprm4State(DUMPNAME("sprmCFItalic")); //  61 chp.fItalic 0,1, 128, or 129 (see below) byte
657 	aTab[ 62] = new Ww1SingleSprm4State(DUMPNAME("sprmCFStrike")); //  62 chp.fStrike 0,1, 128, or 129 (see below) byte
658 	aTab[ 63] = new Ww1SingleSprm4State(DUMPNAME("sprmCFOutline")); //  63 chp.fOutline 0,1, 128, or 129 (see below) byte
659 	aTab[ 64] = new Ww1SingleSprm4State(DUMPNAME("sprmCFShadow")); //  64 chp.fShadow 0,1, 128, or 129 (see below) byte
660 	aTab[ 65] = new Ww1SingleSprm4State(DUMPNAME("sprmCFSmallCaps")); //  65 chp.fSmallCaps 0,1, 128, or 129 (see below) byte
661 	aTab[ 66] = new Ww1SingleSprm4State(DUMPNAME("sprmCFCaps")); //  66 chp.fCaps 0,1, 128, or 129 (see below) byte
662 	aTab[ 67] = new Ww1SingleSprm4State(DUMPNAME("sprmCFVanish")); //  67 chp.fVanish 0,1, 128, or 129 (see below) byte
663 	aTab[ 68] = new Ww1SingleSprmWord(DUMPNAME("sprmCFtc")); //  68 chp.ftc ftc word
664 	aTab[ 69] = new Ww1SingleSprmByte(DUMPNAME("sprmCKul")); //  69 chp.kul kul byte
665 	aTab[ 70] = new Ww1SingleSprm(3, DUMPNAME("sprmCSizePos")); //  70 chp.hps, chp.hpsPos (see below) 3 bytes
666 	aTab[ 71] = new Ww1SingleSprmWord(DUMPNAME("sprmCDxaSpace")); //  71 chp.dxaSpace dxa word
667 	aTab[ 72] = new Ww1SingleSprmWord(DUMPNAME("//")); //  72 //
668 	aTab[ 73] = new Ww1SingleSprmByte(DUMPNAME("sprmCIco")); //  73 chp.ico ico byte
669 	aTab[ 74] = new Ww1SingleSprmByte(DUMPNAME("sprmCHps")); //  74 chp.hps hps !byte!
670 	aTab[ 75] = new Ww1SingleSprmByte(DUMPNAME("sprmCHpsInc")); //  75 chp.hps (see below) byte
671 	aTab[ 76] = new Ww1SingleSprmWord(DUMPNAME("sprmCHpsPos")); //  76 chp.hpsPos hps !word!
672 	aTab[ 77] = new Ww1SingleSprmByte(DUMPNAME("sprmCHpsPosAdj")); //  77 chp.hpsPos hps (see below) byte
673 	aTab[ 78] = new Ww1SingleSprmByteSized(0, DUMPNAME(pUnknown)); //  78 ?chp.fBold, chp.fItalic, chp.fSmallCaps, ...
674 
675 	aTab[ 94] = new Ww1SingleSprmByte(DUMPNAME("sprmPicBrcl")); //  94 pic.brcl brcl (see PIC structure definition) byte
676 	aTab[ 95] = new Ww1SingleSprmByteSized(0, DUMPNAME("sprmPicScale")); //  95 pic.mx, pic.my, pic.dxaCropleft,
677 
678 	aTab[117] = new Ww1SingleSprmByte(DUMPNAME("sprmSBkc")); // 117 sep.bkc bkc byte
679 	aTab[118] = new Ww1SingleSprmBool(DUMPNAME("sprmSFTitlePage")); // 118 sep.fTitlePage 0 or 1 byte
680 	aTab[119] = new Ww1SingleSprmSColumns(DUMPNAME("sprmSCcolumns")); // 119 sep.ccolM1 # of cols - 1 word
681 	aTab[120] = new Ww1SingleSprmWord(DUMPNAME("sprmSDxaColumns")); // 120 sep.dxaColumns dxa word
682 
683 	aTab[122] = new Ww1SingleSprmByte(DUMPNAME("sprmSNfcPgn")); // 122 sep.nfcPgn nfc byte
684 
685 	aTab[125] = new Ww1SingleSprmBool(DUMPNAME("sprmSFPgnRestart")); // 125 sep.fPgnRestart 0 or 1 byte
686 	aTab[126] = new Ww1SingleSprmBool(DUMPNAME("sprmSFEndnote")); // 126 sep.fEndnote 0 or 1 byte
687 	aTab[127] = new Ww1SingleSprmByte(DUMPNAME("sprmSLnc")); // 127 sep.lnc lnc byte
688 	aTab[128] = new Ww1SingleSprmSGprfIhdt(DUMPNAME("sprmSGprfIhdt")); // 128 sep.grpfIhdt grpfihdt (see Headers and Footers topic) byte
689 	aTab[129] = new Ww1SingleSprmWord(DUMPNAME("sprmSNLnnMod")); // 129 sep.nLnnMod non-neg int. word
690 	aTab[130] = new Ww1SingleSprmWord(DUMPNAME("sprmSDxaLnn")); // 130 sep.dxaLnn dxa word
691 	aTab[131] = new Ww1SingleSprmWord(DUMPNAME("sprmSDyaHdrTop")); // 131 sep.dyaHdrTop dya word
692 	aTab[132] = new Ww1SingleSprmWord(DUMPNAME("sprmSDyaHdrBottom")); // 132 sep.dyaHdrBottom dya word
693 	aTab[133] = new Ww1SingleSprmBool(DUMPNAME("sprmSLBetween")); // 133 sep.fLBetween 0 or 1 byte
694 	aTab[134] = new Ww1SingleSprmByte(DUMPNAME("sprmSVjc")); // 134 sep.vjc vjc byte
695 	aTab[135] = new Ww1SingleSprmWord(DUMPNAME("sprmSLnnMin")); // 135 sep.lnnMin lnn word
696 	aTab[136] = new Ww1SingleSprmWord(DUMPNAME("sprmSPgnStart")); // 136 sep.pgnStart pgn word
697 
698 	aTab[146] = new Ww1SingleSprmWord(DUMPNAME("sprmTJc")); // 146 tap.jc jc word (low order byte is significant)
699 	aTab[147] = new Ww1SingleSprmWord(DUMPNAME("sprmTDxaLeft")); // 147 tap.rgdxaCenter (see below) dxa word
700 	aTab[148] = new Ww1SingleSprmWord(DUMPNAME("sprmTDxaGapHalf")); // 148 tap.dxaGapHalf, tap.rgdxaCenter (see below) dxa word
701 
702 	aTab[152] = new Ww1SingleSprmTDefTable10(DUMPNAME("sprmTDefTable10")); // 152 tap.rgdxaCenter, tap.rgtc complex (see below) variable length
703 	aTab[153] = new Ww1SingleSprmWord(DUMPNAME("sprmTDyaRowHeight")); // 153 tap.dyaRowHeight dya word
704 
705 	aTab[158] = new Ww1SingleSprm(4, DUMPNAME("sprmTInsert")); // 158 tap.rgdxaCenter,tap.rgtc complex (see below) 4 bytes
706 	aTab[159] = new Ww1SingleSprmWord(DUMPNAME("sprmTDelete")); // 159 tap.rgdxaCenter, tap.rgtc complex (see below) word
707 	aTab[160] = new Ww1SingleSprm(4, DUMPNAME("sprmTDxaCol")); // 160 tap.rgdxaCenter complex (see below) 4 bytes
708 	aTab[161] = new Ww1SingleSprmWord(DUMPNAME("sprmTMerge")); // 161 tap.fFirstMerged, tap.fMerged complex (see below) word
709 	aTab[162] = new Ww1SingleSprmWord(DUMPNAME("sprmTSplit")); // 162 tap.fFirstMerged, tap.fMerged complex (see below) word
710 	aTab[163] = new Ww1SingleSprm(5, DUMPNAME("sprmTSetBrc10")); // 163 tap.rgtc[].rgbrc complex (see below) 5 bytes
711 }
712 
713 ////////////////////////////////////////////////////////////// SprmPapx
Ww1SprmPapx(sal_uInt8 * pByte,sal_uInt16 nSize)714 Ww1SprmPapx::Ww1SprmPapx(sal_uInt8* pByte, sal_uInt16 nSize) :
715 	Ww1Sprm(Sprm(pByte, nSize), SprmSize(pByte, nSize))
716 {
717 	memset(&aPapx, 0, sizeof(aPapx));
718 	memcpy(&aPapx, pByte, nSize<sizeof(aPapx)?nSize:sizeof(aPapx));
719 }
720 
SprmSize(sal_uInt8 *,sal_uInt16 nSize)721 sal_uInt16 Ww1SprmPapx::SprmSize(sal_uInt8*, sal_uInt16 nSize)
722 {
723 	sal_uInt16 nRet = 0;
724 	if (nSize >= sizeof(W1_PAPX))
725 		nRet = nSize - ( sizeof(W1_PAPX) - 1 ); // im W1_PAPX ist das
726 												// 1. SprmByte enthalten
727 	return nRet;
728 }
729 
Sprm(sal_uInt8 * pByte,sal_uInt16 nSize)730 sal_uInt8* Ww1SprmPapx::Sprm(sal_uInt8* pByte, sal_uInt16 nSize)
731 {
732 	sal_uInt8* pRet = NULL;
733 	if (nSize >= sizeof(W1_PAPX))
734 		pRet = ((W1_PAPX*)(pByte))->grpprlGet();
735 	return pRet;
736 }
737 
738 /////////////////////////////////////////////////////////////////// Plc
Ww1Plc(Ww1Fib & rInFib,sal_uLong ulFilePos,sal_uInt16 nInCountBytes,sal_uInt16 nInItemSize)739 Ww1Plc::Ww1Plc(Ww1Fib& rInFib, sal_uLong ulFilePos, sal_uInt16 nInCountBytes,
740 	sal_uInt16 nInItemSize)
741 	: p(0), nCountBytes(nInCountBytes), iMac(0), nItemSize(nInItemSize),
742 	bOK(false), rFib(rInFib)
743 {
744 	if (!nCountBytes)
745 		bOK = true;
746 	else
747 	{
748 		if (rFib.GetStream().Seek(ulFilePos) == (sal_uLong)ulFilePos)
749 		{
750 			if ((p = new sal_uInt8[nCountBytes]) != NULL)
751 			{
752 				if (rFib.GetStream().Read(p, nCountBytes) == (sal_uLong)nCountBytes)
753 				{
754 					bOK = true;
755 					iMac = (nCountBytes -
756 						sizeof(SVBT32)) / (sizeof(SVBT32) + nItemSize);
757 					DBG_ASSERT(iMac * ((sal_uInt16)sizeof(sal_uLong) + nItemSize) +
758 					 (sal_uInt16)sizeof(SVBT32) == nCountBytes, "Ww1Plc");
759 				}
760 			}
761 		}
762 	}
763 }
764 
~Ww1Plc()765 Ww1Plc::~Ww1Plc()
766 {
767 	delete p;
768 }
769 
Seek(sal_uLong ulSeek,sal_uInt16 & nIndex)770 void Ww1Plc::Seek(sal_uLong ulSeek, sal_uInt16& nIndex)
771 {
772 	if (iMac)
773 		for (;nIndex <= iMac && Where(nIndex) < ulSeek;nIndex++)
774 			;
775 }
776 
Where(sal_uInt16 nIndex)777 sal_uLong Ww1Plc::Where(sal_uInt16 nIndex)
778 {
779 	sal_uLong ulRet = 0xffffffff;
780 	DBG_ASSERT(nIndex <= iMac, "index out of bounds");
781 	if (iMac && nIndex <= iMac)
782 		ulRet = SVBT32ToUInt32(p + sizeof(SVBT32) * nIndex);
783 	return ulRet;
784 }
785 
GetData(sal_uInt16 nIndex)786 sal_uInt8* Ww1Plc::GetData(sal_uInt16 nIndex)
787 {
788 	sal_uInt8* pRet = NULL;
789 	DBG_ASSERT(nIndex < iMac, "index out of bounds");
790 	if (nIndex < iMac)
791 		pRet = p + (iMac + 1) * sizeof(SVBT32) +
792 		 nIndex * nItemSize; // Pointer auf Inhalts-Array
793 	return pRet;
794 }
795 
796 /////////////////////////////////////////////////////////////////// Sep
797 
798 //////////////////////////////////////////////////////////////// PlcSep
799 
800 //////////////////////////////////////////////////////////////// PlcPap
801 
802 //////////////////////////////////////////////////////////////// PlcChp
803 
804 //////////////////////////////////////////////////////////////// PlcFnr
805 
806 ///////////////////////////////////////////////////////////// PlcFnText
807 
808 ///////////////////////////////////////////////////////////// PlcFields
809 
810 ///////////////////////////////////////////////////////////// PlcBookmarks
811 // class Ww1StringList liest im Ctor eine Anzahl von P-Strings aus dem Stream
812 // in den Speicher und patcht sie zu C-Strings um.
813 // Die Anzahl wird in nMax zurueckgeliefert.
814 // im Index 0 stehen alle Strings nacheinander, ab Index 1 werden
815 // die einzelnen Strings referenziert.
Ww1StringList(SvStream & rSt,sal_uLong nFc,sal_uInt16 nCb)816 Ww1StringList::Ww1StringList( SvStream& rSt, sal_uLong nFc, sal_uInt16 nCb )
817 	: pIdxA(0), nMax(0)
818 {
819 	if( nCb > 2 )			 // ueberhaupt Eintraege ?
820 	{
821 		SVBT16 nCountBytes;
822 		DBG_ASSERT(nCb > sizeof(nCountBytes), "Ww1StringList");
823 		if (rSt.Seek(nFc) == (sal_uLong)nFc)
824 			if (rSt.Read(nCountBytes, sizeof(nCountBytes))
825 			 		== sizeof(nCountBytes)) // Laenge steht hier nochmal
826 			{
827 				DBG_ASSERT(SVBT16ToShort(nCountBytes)
828 				 		== nCb, "redundant-size missmatch");
829 									// hoffentlich sind sie immer gleich
830 				sal_Char* pA = new sal_Char[nCb - sizeof(nCountBytes) + 1];
831 									// Alloziere PString-Array
832 				//~ Ww1: new-NULL
833 				if (rSt.Read(pA, nCb - sizeof(nCountBytes))
834 						== (sal_uLong)nCb - sizeof(nCountBytes))	// lese alle
835 				{}// do nothing
836 									// Zaehle, wieviele Fonts enthalten
837 				long nLeft = nCb - sizeof(nCountBytes);
838 				sal_Char* p = pA;
839 				while (1)
840 				{
841 					sal_uInt16 nNextSiz;
842 					nNextSiz = *p + 1;
843 					if(nNextSiz > nLeft)
844 						break;
845 					nMax++;
846 					nLeft -= nNextSiz;
847 					if(nLeft < 1)			// naechste Laenge muss gelesen werden koennen
848 						break;
849 					p = p + nNextSiz;
850 				}
851 				if (nMax)
852 				{
853 					pIdxA = new sal_Char*[nMax+1];		// alloziere Index-Array
854 					pIdxA[0] = pA;						// Index 0 : alles
855 														// ab Index 1 C-Strings
856 					pIdxA[1] = pA + 1;					// fuelle Index-Array
857 					sal_uInt16 i = 2;
858 					p = pA;
859 					sal_uInt8 nL = *p;
860 					while(1)
861 					{
862 						p += nL + 1;					// Neues Laengen-Byte
863 						nL = *p;						// merke Laenge
864 						*p = '\0';						// mach C-String draus
865 						if( i > nMax )
866 							break;
867 						pIdxA[i] = p + 1;				// Ptr auf C-String
868 						i++;
869 					}
870 				}
871 				else
872 					pIdxA = 0;	// Keine Eintraege -> kein Array
873 			}
874 	}
875 }
GetStr(sal_uInt16 nNum) const876 const String Ww1StringList::GetStr( sal_uInt16 nNum ) const
877 {
878 	String sRet;
879 	if( nNum <= nMax )
880 		sRet = String( pIdxA[ nNum+1 ], RTL_TEXTENCODING_MS_1252 );
881 	return sRet;
882 }
883 
Ww1Bookmarks(Ww1Fib & rInFib)884 Ww1Bookmarks::Ww1Bookmarks(Ww1Fib& rInFib)
885 	: aNames(rInFib), rFib(rInFib), nIsEnd(0)
886 {
887 	pPos[0] = new Ww1PlcBookmarkPos(rFib, rFib.GetFIB().fcPlcfbkfGet(),
888 									rFib.GetFIB().cbPlcfbkfGet(), sal_False);
889 	nPlcIdx[0] = 0;
890 	pPos[1] = new Ww1PlcBookmarkPos(rFib, rFib.GetFIB().fcPlcfbklGet(),
891 									rFib.GetFIB().cbPlcfbklGet(), sal_True);
892 	nPlcIdx[1] = 0;
893 	bOK = !aNames.GetError() && !pPos[0]->GetError() && !pPos[1]->GetError();
894 }
895 
896 // Der Operator ++ hat eine Tuecke: Wenn 2 Bookmarks aneinandergrenzen, dann
897 // sollte erst das Ende des ersten und dann der Anfang des 2. erreicht werden.
898 // Liegen jedoch 2 Bookmarks der Laenge 0 aufeinander, *muss* von jedem Bookmark
899 // erst der Anfang und dann das Ende gefunden werden.
900 // Der Fall: ][
901 //            [...]
902 //           ][
903 // ist noch nicht geloest, dabei muesste ich in den Anfangs- und Endindices
904 // vor- und zurueckspringen, wobei ein weiterer Index oder ein Bitfeld
905 // oder etwas aehnliches zum Merken der bereits abgearbeiteten Bookmarks
906 // noetig wird.
operator ++(int)907 void Ww1Bookmarks::operator ++( int )
908 {
909 	if( bOK )
910 	{
911 		nPlcIdx[nIsEnd]++;
912 
913 		sal_uLong l0 = pPos[0]->Where(nPlcIdx[0]);
914 		sal_uLong l1 = pPos[1]->Where(nPlcIdx[1]);
915 		if( l0 < l1 )
916 			nIsEnd = 0;
917 		else if( l1 < l0 )
918 			nIsEnd = 1;
919 		else
920 			nIsEnd = ( nIsEnd ) ? 0 : 1;
921 	}
922 }
923 
GetHandle() const924 long Ww1Bookmarks::GetHandle() const
925 {
926 	if( bOK )
927 	{
928 		if( nIsEnd )
929 			return nPlcIdx[1];
930 
931 		const sal_uInt8* p = pPos[0]->GetData( nPlcIdx[0] );
932 		if( p )
933 			return SVBT16ToShort( p );
934 	}
935 	return LONG_MAX;
936 }
937 
Len() const938 long Ww1Bookmarks::Len() const
939 {
940 	if( nIsEnd )
941 	{
942 		DBG_ASSERT( sal_False, "Falscher Aufruf (1) von Ww1Bookmarks::Len()" );
943 		return 0;
944 	}
945 	sal_uInt16 nEndIdx = SVBT16ToShort(pPos[0]->GetData(nPlcIdx[0]));
946 	return pPos[1]->Where(nEndIdx) - pPos[0]->Where(nPlcIdx[0]);
947 }
948 
GetName() const949 const String Ww1Bookmarks::GetName() const
950 {
951 	if( nIsEnd )
952 		return String::CreateFromAscii( RTL_CONSTASCII_STRINGPARAM( "???" ));
953 	return aNames.GetStr( nPlcIdx[0] );
954 }
955 
956 /////////////////////////////////////////////////////////////////// Fkp
Ww1Fkp(SvStream & rStream,sal_uLong ulFilePos,sal_uInt16 _nItemSize)957 Ww1Fkp::Ww1Fkp(SvStream& rStream, sal_uLong ulFilePos, sal_uInt16 _nItemSize) :
958 	nItemSize(_nItemSize),
959 	bOK(sal_False)
960 {
961 	if (rStream.Seek(ulFilePos) == (sal_uLong)ulFilePos)
962 		if (rStream.Read(aFkp, sizeof(aFkp)) == sizeof(aFkp))
963 			bOK = sal_True;
964 }
965 
Where(sal_uInt16 nIndex)966 sal_uLong Ww1Fkp::Where(sal_uInt16 nIndex)
967 {
968 	sal_uLong lRet = 0xffffffff;
969 	DBG_ASSERT(nIndex<=Count(), "index out of bounds");
970 	if (nIndex<=Count())
971 		lRet = SVBT32ToUInt32(aFkp+nIndex*sizeof(SVBT32));
972 	return lRet;
973 }
974 
GetData(sal_uInt16 nIndex)975 sal_uInt8* Ww1Fkp::GetData(sal_uInt16 nIndex)
976 {
977 	sal_uInt8* pRet = NULL;
978 	DBG_ASSERT(nIndex<=Count(), "index out of bounds");
979 	if (nIndex<=Count())
980 		pRet = aFkp + (Count()+1) * sizeof(SVBT32) +
981 		 nIndex * nItemSize; // beginn der strukturen
982 	return pRet;
983 }
984 
985 //////////////////////////////////////////////////////////////// FkpPap
Fill(sal_uInt16 nIndex,sal_uInt8 * & p,sal_uInt16 & rnCountBytes)986 sal_Bool Ww1FkpPap::Fill(sal_uInt16 nIndex, sal_uInt8*& p, sal_uInt16& rnCountBytes)
987 {
988 	DBG_ASSERT( nIndex < Count(), "Ww1FkpPap::Fill() Index out of Range" );
989 	sal_uInt16 nOffset = SVBT8ToByte(GetData(nIndex)) * 2;
990 	if (nOffset)
991 	{
992 		DBG_ASSERT(nOffset>(sal_uInt16)(Count()*sizeof(SVBT32)), "calc error");
993 //		rnCountBytes = SVBT8ToByte(aFkp+nOffset) * 2 + 1;  // SH: +1 ?????
994 		rnCountBytes = SVBT8ToByte(aFkp+nOffset) * 2;
995 		nOffset += sizeof(SVBT8);
996 		if( nOffset + rnCountBytes < 511 )	// SH: Assert schlug 1 zu frueh zu
997 			rnCountBytes++;                 // SH: Ich weiss nicht genau,
998 											// ob das letzte Byte des PAPX
999 											// genutzt wird, aber so vergessen
1000 											// wir keins und sind trotzdem
1001 											// auf der sicheren Seite
1002 		DBG_ASSERT(nOffset+rnCountBytes <= 511, "calc error");
1003 		p = aFkp + nOffset;
1004 	}
1005 	else
1006 	{
1007 		p = NULL;
1008 		rnCountBytes = 0;
1009 	}
1010 	return sal_True;
1011 }
1012 
1013 //////////////////////////////////////////////////////////////// FkpChp
Fill(sal_uInt16 nIndex,W1_CHP & aChp)1014 sal_Bool Ww1FkpChp::Fill(sal_uInt16 nIndex, W1_CHP& aChp)
1015 {
1016 	DBG_ASSERT( nIndex < Count(), "Ww1FkpChp::Fill() Index out of Range" );
1017 	memset(&aChp, 0, sizeof(aChp));	// Default, da verkuerzt gespeichert
1018 	sal_uInt16 nOffset = GetData(nIndex)[0] * 2;
1019 	if (nOffset)
1020 	{
1021 		DBG_ASSERT(nOffset>(sal_uInt16)(Count()*sizeof(SVBT32)), "calc error");
1022 		sal_uInt16 nCountBytes = aFkp[nOffset];
1023 		nOffset += sizeof(SVBT8);
1024 		DBG_ASSERT(nCountBytes <= 511-nOffset, "calc error");
1025 		DBG_ASSERT(nCountBytes <= sizeof(aChp), "calc error");
1026 		memcpy(&aChp, aFkp+nOffset, nCountBytes);
1027 	}
1028 	return sal_True;
1029 }
1030 
1031 ///////////////////////////////////////////////////////////////// Assoc
Ww1Assoc(Ww1Fib & _rFib)1032 Ww1Assoc::Ww1Assoc(Ww1Fib& _rFib)
1033 	: rFib(_rFib), pBuffer(NULL), bOK(sal_False)
1034 {
1035 	sal_uInt16 cb = rFib.GetFIB().cbSttbfAssocGet();
1036 	sal_uInt16 i;
1037 
1038 	for ( i = 0; i < MaxFields; i++ )
1039 		pStrTbl[i] = NULL;
1040 	if ((pBuffer = new sal_Char[cb]) != NULL
1041 	 && rFib.GetStream().Seek(rFib.GetFIB().fcSttbfAssocGet()) ==
1042 		rFib.GetFIB().fcSttbfAssocGet()
1043 	 && rFib.GetStream().Read(pBuffer, cb) == cb)
1044 	{
1045 		sal_uInt16 j;
1046 		DBG_ASSERT( cb == SVBT16ToShort( *(SVBT16*)pBuffer ), "size missmatch");
1047 		for (i=0,j=sizeof(SVBT16);j<cb && i<Criteria1;i++)
1048 		{
1049 			pStrTbl[i] = pBuffer+j;
1050 			j += (*pBuffer + j) + 1;
1051 		}
1052 		bOK = sal_True;
1053 	}
1054 }
1055 
GetStr(sal_uInt16 code)1056 String Ww1Assoc::GetStr(sal_uInt16 code)
1057 {
1058 	String sRet;
1059 	DBG_ASSERT(code<MaxFields, "out of range");
1060 	if (pStrTbl[code] != NULL)
1061 		for( sal_uInt16 i=0;i<pStrTbl[code][0];i++ )
1062 			sRet += String( pStrTbl[code][i+1], RTL_TEXTENCODING_MS_1252 );
1063 	return sRet;
1064 }
1065 
1066 /////////////////////////////////////////////////////////////////// Pap
Ww1Pap(Ww1Fib & _rFib)1067 Ww1Pap::Ww1Pap(Ww1Fib& _rFib)
1068 	: Ww1PlcPap(_rFib), nPlcIndex(0), nPushedPlcIndex(0xffff), nFkpIndex(0),
1069 	nPushedFkpIndex(0xffff), ulOffset(0), pPap(0)
1070 {
1071 }
1072 
Seek(sal_uLong ulSeek)1073 void Ww1Pap::Seek(sal_uLong ulSeek)
1074 {
1075 	while (ulSeek > Where())
1076 		(*this)++;
1077 }
1078 
1079 // SH: Where hat einen Parameter mitbekommen, der sagt, ob bei Neuanlegen eines
1080 // Fkps der zugehoerige Index auf 0 gesetzt werden soll
1081 // ( darf fuer Push/Pop nicht passieren )
1082 // Ein eleganterer Weg faellt mir auf die Schnelle nicht ein
Where(sal_Bool bSetIndex)1083 sal_uLong Ww1Pap::Where( sal_Bool bSetIndex )
1084 {
1085 	sal_uLong ulRet = 0xffffffff;
1086 	if (pPap == NULL)
1087 		if (nPlcIndex < Count())
1088 		{
1089 			pPap = new Ww1FkpPap(rFib.GetStream(),
1090 						SVBT16ToShort(GetData(nPlcIndex)) << 9);
1091 			if( bSetIndex )
1092 				nFkpIndex = 0;
1093 		}
1094 	if (pPap != NULL)
1095 //		if (nFkpIndex < pPap->Count())
1096 		if (nFkpIndex <= pPap->Count())
1097 			ulRet = pPap->Where(nFkpIndex) - rFib.GetFIB().fcMinGet();
1098 	return ulRet;
1099 }
1100 
operator ++(int)1101 void Ww1Pap::operator++(int)
1102 {
1103 	if (pPap != NULL)
1104 //		if (++nFkpIndex >= pPap->Count())
1105 		if (++nFkpIndex > pPap->Count())
1106 		{
1107 			delete pPap;
1108 			pPap = NULL;
1109 			nPlcIndex++;
1110 		}
1111 }
1112 
1113 // SH: FindSprm sucht in grpprl nach Sprm nId
1114 // Rueckgabe: Pointer oder 0
FindSprm(sal_uInt16 nId,sal_uInt8 * pStart,sal_uInt8 * pEnd)1115 sal_Bool Ww1Pap::FindSprm(sal_uInt16 nId, sal_uInt8* pStart, sal_uInt8* pEnd)
1116 {
1117     Ww1Sprm aSprm( pStart, static_cast< sal_uInt16 >(pEnd-pStart) );
1118 	sal_uInt16 nC = aSprm.Count();
1119     sal_uInt16 i;
1120 	sal_uInt8 nI;
1121 	sal_uInt16 nLen;
1122 	sal_uInt8 *pData;
1123 	for( i = 0; i < nC; i++ ){
1124 		aSprm.Fill( i, nI, nLen, pData );
1125 		if( nI == nId )
1126 			return sal_True;
1127 	}
1128 	return sal_False;
1129 }
1130 
HasId0(sal_uInt16 nId)1131 sal_Bool Ww1Pap::HasId0(sal_uInt16 nId)
1132 {
1133 	sal_Bool bRet = sal_False;
1134 	UpdateIdx();
1135 
1136 	if( !pPap ){
1137 		DBG_ASSERT( sal_False, "Ww1Pap::HasId():: kann kein pPap erzeugen" );
1138 		return sal_False;
1139 	}
1140 
1141 	sal_uInt8* pByte;
1142 	sal_uInt16 n;
1143 	if( pPap->Fill(nFkpIndex, pByte, n) ){
1144 		sal_uInt8* p2 = ((W1_PAPX*)(pByte))->grpprlGet(); // SH: Offset fehlte
1145 		bRet = FindSprm( nId, p2, pByte + n );
1146 	}
1147 	return bRet;
1148 }
1149 
HasId(sal_uInt16 nId)1150 sal_Bool Ww1Pap::HasId(sal_uInt16 nId)
1151 {
1152 	sal_Bool bRet = sal_False;
1153 	sal_uInt16 nPushedPlcIndex2 = nPlcIndex;
1154 	sal_uInt16 nPushedFkpIndex2 = nFkpIndex;
1155 	bRet = HasId0( nId );
1156 	if (nPlcIndex != nPushedPlcIndex2)
1157 	{
1158 		delete pPap;
1159 		pPap = NULL;
1160 	}
1161 	nPlcIndex = nPushedPlcIndex2;
1162 	nFkpIndex = nPushedFkpIndex2;
1163 	Where( sal_False );
1164 	return bRet;
1165 }
1166 
1167 /////////////////////////////////////////////////////////////////// Chp
Ww1Chp(Ww1Fib & _rFib)1168 Ww1Chp::Ww1Chp(Ww1Fib& _rFib)
1169 	: Ww1PlcChp(_rFib), nPlcIndex(0), nPushedPlcIndex(0xffff), nFkpIndex(0),
1170 	nPushedFkpIndex(0xffff), ulOffset(0), pChp(0)
1171 {
1172 }
1173 
Seek(sal_uLong ulSeek)1174 void Ww1Chp::Seek(sal_uLong ulSeek)
1175 {
1176 	while (ulSeek > Where())
1177 		(*this)++;
1178 }
1179 
1180 // SH: Where hat einen Parameter mitbekommen, der sagt, ob bei Neuanlegen eines
1181 // Fkps der zugehoerige Index auf 0 gesetzt werden soll
1182 // ( darf fuer Push/Pop nicht passieren )
1183 // Ein eleganterer Weg faellt mir auf die Schnelle nicht ein
Where(sal_Bool bSetIndex)1184 sal_uLong Ww1Chp::Where( sal_Bool bSetIndex )
1185 {
1186 	sal_uLong ulRet = 0xffffffff;
1187 	if (pChp == NULL)
1188 		if (nPlcIndex < Count())
1189 		{
1190 			pChp = new Ww1FkpChp(rFib.GetStream(),
1191 						SVBT16ToShort(GetData(nPlcIndex)) << 9);
1192 			if( bSetIndex )
1193 				nFkpIndex = 0;
1194 		}
1195 	if (pChp != NULL)
1196 //		if (nFkpIndex < pChp->Count())
1197 		if (nFkpIndex <= pChp->Count())
1198 			ulRet = pChp->Where(nFkpIndex) -
1199 					 rFib.GetFIB().fcMinGet() - ulOffset;
1200 	return ulRet;
1201 }
1202 
operator ++(int)1203 void Ww1Chp::operator++(int)
1204 {
1205 	if (pChp != NULL)
1206 //		if (++nFkpIndex >= pChp->Count())
1207 		if (++nFkpIndex > pChp->Count())
1208 		{
1209 			delete pChp;
1210 			pChp = NULL;
1211 			nPlcIndex++;
1212 		}
1213 }
1214 
1215 ////////////////////////////////////////////////////////////// Manager
Ww1Manager(SvStream & rStrm,sal_uLong nFieldFlgs)1216 Ww1Manager::Ww1Manager(SvStream& rStrm, sal_uLong nFieldFlgs)
1217 	: bOK(sal_False), bInTtp(sal_False), bInStyle(sal_False), bStopAll(sal_False), aFib(rStrm),
1218 	aDop(aFib), aFonts(aFib, nFieldFlgs), aDoc(aFib), pDoc(&aDoc),
1219 	ulDocSeek(0), pSeek(&ulDocSeek), aFld(aFib), pFld(&aFld), aChp(aFib),
1220 	aPap(aFib), aFtn(aFib), aBooks(aFib),
1221 	aSep(aFib, aDop.GetDOP().grpfIhdtGet())
1222 {
1223 	bOK =  !aFib.GetError()
1224 		&& !aFib.GetFIB().fComplexGet()
1225 		&& !aDoc.GetError()
1226 		&& !aSep.GetError()
1227 		&& !aPap.GetError()
1228 		&& !aChp.GetError()
1229 		&& !aFld.GetError()
1230 		&& !aFtn.GetError()
1231 		&& !aBooks.GetError();
1232 }
1233 
HasInTable()1234 sal_Bool Ww1Manager::HasInTable()
1235 {
1236 	return aPap.HasId(24); // Ww1SingleSprmPFInTable
1237 }
1238 
HasTtp()1239 sal_Bool Ww1Manager::HasTtp()
1240 {
1241 	return aPap.HasId(25); // Ww1SingleSprmPTtp
1242 }
1243 
HasPPc()1244 sal_Bool Ww1Manager::HasPPc()
1245 {
1246 	return aPap.HasId(29); // Ww1SingleSprmPPc
1247 }
1248 
HasPDxaAbs()1249 sal_Bool Ww1Manager::HasPDxaAbs()
1250 {
1251 	return aPap.HasId(26); // Ww1SingleSprmPDxaAbs
1252 }
1253