?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
merge the formfield patch from ooo-build
[ooovba.git] / sw / source / filter / ww1 / w1filter.cxx
blob60cc3b95e3f6c6b20e2df311208d04e4af91687c
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: w1filter.cxx,v $
10 * $Revision: 1.21 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_sw.hxx"
33 #include <hintids.hxx>
34
35 #include <tools/solar.h>
36 #include <comphelper/string.hxx>
37 #include <svx/paperinf.hxx>
38 #include <svtools/filter.hxx>
39 #ifndef _GRAPH_HXX //autogen
40 #include <vcl/graph.hxx>
41 #endif
42 #include <svx/fontitem.hxx>
43 #include <svx/lrspitem.hxx>
44 #include <svx/ulspitem.hxx>
45 #include <svx/wghtitem.hxx>
46 #include <svx/postitem.hxx>
47 #include <svx/crsditem.hxx>
48 #ifndef _SVX_CNTRITEM_HXX //autogen
49 #include <svx/cntritem.hxx>
50 #endif
51 #include <svx/cmapitem.hxx>
52 #include <svx/fhgtitem.hxx>
53 #include <svx/udlnitem.hxx>
54 #include <svx/wrlmitem.hxx>
55 #include <svx/colritem.hxx>
56 #include <svx/kernitem.hxx>
57 #include <svx/escpitem.hxx>
58 #ifndef _SVX_TSTPITEM_HXX //autogen
59 #include <svx/tstpitem.hxx>
60 #endif
61 #include <svtools/urihelper.hxx>
62 #include <fmtfsize.hxx>
63 #include <doc.hxx>
64 #include <pam.hxx>
65 #include <ndtxt.hxx>
66 #include <pagedesc.hxx>
67 #include <flddat.hxx>
68 #include <reffld.hxx>
69 #include <expfld.hxx>
70 #include <docufld.hxx>
71 #include <ftninfo.hxx>
72 #include <section.hxx> // class SwSection
73 #include <fltini.hxx>
74 #include <w1par.hxx>
75
76 #include <docsh.hxx>
77 #include <swerror.h>
78 #include <mdiexp.hxx>
79 #ifndef _STATSTR_HRC
80 #include <statstr.hrc>
81 #endif
82 #if OSL_DEBUG_LEVEL > 1
83 #include <stdio.h>
84 #endif
85
86 #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
87 #include <com/sun/star/document/XDocumentProperties.hpp>
88
89 #define MAX_FIELDLEN 64000
90
91 using namespace nsSwDocInfoSubType;
92
93
94 ///////////////////////////////////////////////////////////////////////
95 //
96 // hier stehen die methoden operator<<, Out, Start und Stop mit
97 // folgender Bedeutung: wenn moeglich wird die information aus dem
98 // dokument per
99 // operator<<()
100 // in die shell uebertragen. sind jedoch weitere parameter noetig
101 // wurde der name
102 // Out()
103 // gewaehlt. ist ein bereich zu kennzeichnen (zB bei attributen
104 // von/bis), heissen die methoden
105 // Start(), Stop()
106 // alle diese methoden stehen in diesem modul, das fuer den filter,
107 // jedoch nicht fuer den dumper noetig ist. und da alle regeln ihre
108 // ausnahme haben: hier stehen auch methoden, die aus anderen gruenden
109 // fuer den dumper sinnlos sind, zB wenn sie auf sv-strukturen beruhen
110 // wie zB GetFont() auf SvxFontItem.
111 //
112
113 /////////////////////////////////////////////////////////////// Manager
114 Ww1Shell& operator <<(Ww1Shell& rOut, Ww1Manager& This)
115 {
116 // verhindern, das bei rekusivem aufruf dies mehrfach passiert:
117 if (!This.Pushed())
118 {
119 { // der wird nur temporaer gebraucht:
120 This.SetInStyle( TRUE );
121 Ww1StyleSheet(This.aFib).Out(rOut, This);
122 This.SetInStyle( FALSE );
123 }
124 { // dieser auch:
125 Ww1Assoc(This.aFib).Out(rOut);
126 }
127 // dieser nicht, der ist bereits member:
128 This.aDop.Out(rOut);
129 // Jetzt entscheiden, wie Seitenvorlagen erzeugt werden
130 if (This.GetSep().Count() <= 1)
131 rOut.SetUseStdPageDesc();
132 }
133 // und jetzt das eigentliche dok:
134 sal_Unicode cUnknown = ' ';
135 while (*This.pSeek < This.pDoc->Count())
136 {
137 // ausgabe des ProgressState nur, wenn im haupttext, da sonst
138 // nicht bestimmt werden kann, wie weit wir sind:
139 if (!This.Pushed())
140 ::SetProgressState(This.Where() * 100 / This.pDoc->Count(),
141 rOut.GetDoc().GetDocShell());
142 // hier werden abwechselnd die attribute und die zeichen in die
143 // shell gepumpt. die positionen werden durch das lesen der
144 // zeichen aus dem manager hoch- gezaehlt. erst alle attribute:
145 This.Out(rOut, cUnknown);
146 // das textdocument pDoc ist ein Ww1PlainText, dessen Out()
147 // methode solange ausgibt, bis entweder ein sonderzeichen
148 // auftaucht oder die anzahl der auszugebenden zeichen erreicht
149 // ist:
150 cUnknown = This.pDoc->Out(rOut, *This.pSeek);
151 }
152 This.SetStopAll(TRUE);
153 This.OutStop(rOut, cUnknown); // Damit die Attribute am Ende geschlossen
154 This.SetStopAll(FALSE); // werden
155 return rOut;
156 }
157
158 void Ww1Manager::OutStop(Ww1Shell& rOut, sal_Unicode cUnknown)
159 {
160 // Bookmarks brauchen nicht beendet werden ???
161 if (pFld)
162 pFld->Stop(rOut, *this, cUnknown);
163 if (!Pushed())
164 aFtn.Stop(rOut, *this, cUnknown);
165 if (1)
166 aChp.Stop(rOut, *this, cUnknown);
167 if (1)
168 aPap.Stop(rOut, *this, cUnknown);
169 if (!Pushed())
170 aSep.Stop(rOut, *this, cUnknown);
171 }
172
173 void Ww1Manager::OutStart( Ww1Shell& rOut )
174 {
175 // alle attribute, die's brauchen beginnen
176 if (!Pushed())
177 aSep.Start(rOut, *this);
178 if (1)
179 aPap.Start(rOut, *this);
180 if (1)
181 aChp.Start(rOut, *this);
182 if (!Pushed())
183 aFtn.Start(rOut, *this);
184 if (pFld)
185 pFld->Start(rOut, *this);
186 if (!Pushed())
187 aBooks.Start(rOut, *this);
188 // bestimmen, wo das naechste Ereigniss ist:
189 ULONG ulEnd = pDoc->Count(); // spaetestens am textende
190 if (!Pushed())
191 if (ulEnd > aSep.Where()) // naechster Sep vorher?
192 ulEnd = aSep.Where();
193 if (1)
194 if (ulEnd > aPap.Where()) // naechster Pap vorher?
195 ulEnd = aPap.Where();
196 if (1)
197 if (ulEnd > aChp.Where()) // naechster Chp vorher?
198 ulEnd = aChp.Where();
199 if (!Pushed())
200 if (ulEnd > aFtn.Where()) // naechster Ftn vorher?
201 ulEnd = aFtn.Where();
202 if (pFld)
203 if (ulEnd > pFld->Where()) // naechster Fld vorher?
204 ulEnd = pFld->Where();
205 if (!Pushed())
206 if (ulEnd > aBooks.Where()) // naechster Bookmark vorher?
207 ulEnd = aBooks.Where();
208 *pSeek = Where(); // momentane position
209 if (*pSeek < ulEnd) // sind wir bereits weiter?
210 *pSeek = ulEnd;
211 }
212
213 void Ww1Manager::Out(Ww1Shell& rOut, sal_Unicode cUnknown)
214 {
215 // Je nach modus wird hier mit feldern, fusznoten, zeichenattributen,
216 // absatzatributen und sektionen wie folgt verfahren: von allen wird
217 // zuallererst die stop-methoden gerufen. stellt das objekt fest, dasz
218 // etwas zu beenden ist (natuerlich nicht im ersten durchgang) beendet
219 // es dies, ansonsten ist der aufruf wirkungslos. dann werden
220 // unbehandelte sonderzeichen augegeben. das werden genauso alle
221 // start-methoden gerufen und danach per where festgestellt, an
222 // welcher stelle die naechste aktion zu erwarten ist.
223 //
224 // ist der manager in einem ge'push'ten mode, werden bestimmte
225 // elemente ausgeklammert. felder werden wiederum nur in besonderen
226 // faellen augeklammert, wenn naemlich bereiche ausgegeben werden, die
227 // keine felder enthalten koennen. charakterattribute und
228 // paragraphenattribute werden jedoch nie ausgeklammert. die if (1)
229 // wurden zur verdeutlichung der einheitlichkeit eingefuegt.
230
231 // Erstmal eine Sonderbehandlung fuer Tabellen:
232 // die wichtigen Attribute lassen sich am Besten vor Beendigung derselben
233 // abfragen.
234 // Optimierung: Sie werden nur auf sinnvolle Werte gesetzt, wenn
235 // das 0x07-Zeiche ansteht.
236
237 BOOL bLIsTtp = FALSE;
238 BOOL bLHasTtp = FALSE;
239 if( cUnknown == 0x07 )
240 {
241 bLIsTtp = IsInTtp();
242 bLHasTtp = HasTtp();
243 }
244
245 OutStop( rOut, cUnknown ); // Attrs ggfs. beenden
246
247 // meta-zeichen interpretieren:
248 if (!Ww1PlainText::IsChar(cUnknown))
249 switch (cUnknown)
250 {
251 case 0x02:
252 // dontknow
253 break;
254 case 0x07: // table
255 if (rOut.IsInTable() && HasInTable() && !bLIsTtp && !bLHasTtp)
256 rOut.NextTableCell();
257 break;
258 case 0x09: // tab
259 rOut.NextTab();
260 break;
261 case 0x0a: // linefeed
262 rOut.NextParagraph();
263 break;
264 case 0x0b: // linebreak
265 if (rOut.IsInTable())
266 // rOut.NextBand(); // war Stuss
267 ;
268 else
269 rOut.NextLine();
270 break;
271 case 0x0d: // carriage return
272 // ignore
273 break;
274 case 0x0c: // pagebreak
275 rOut.NextPage();
276 break;
277 case 0x14: // sectionendchar
278 // ignore here
279 break;
280 default:
281 break;
282 }
283
284 OutStart( rOut ); // Attrs ggfs. starten und Naechste Pos berechnen
285 }
286
287 SvxFontItem Ww1Manager::GetFont(USHORT nFCode)
288 {
289 return aFonts.GetFont(nFCode);
290 }
291
292 void Ww1Manager::Push0(Ww1PlainText* _pDoc, ULONG ulSeek, Ww1Fields* _pFld)
293 {
294 DBG_ASSERT(!Pushed(), "Ww1Manager");
295 this->pDoc = _pDoc;
296 pSeek = new ULONG;
297 *pSeek = pDoc->Where();
298 aPap.Push(ulSeek);
299 aChp.Push(ulSeek);
300 this->pFld = _pFld;
301 }
302
303 // ulSeek ist der FC-Abstand zwischen Hauptest-Start und Sondertext-Start
304 // ulSeek2 ist der Offset dieses bestimmten Sondertextes im Sondertext-Bereich,
305 // also z.B. der Offset des speziellen K/F-Textes
306 void Ww1Manager::Push1(Ww1PlainText* _pDoc, ULONG ulSeek, ULONG ulSeek2,
307 Ww1Fields* _pFld)
308 {
309 DBG_ASSERT(!Pushed(), "Ww1Manager");
310 this->pDoc = _pDoc;
311 pSeek = new ULONG;
312 *pSeek = pDoc->Where();
313 aPap.Push(ulSeek + ulSeek2);
314 aChp.Push(ulSeek + ulSeek2);
315 if( _pFld )
316 _pFld->Seek( ulSeek2 );
317 this->pFld = _pFld;
318 }
319
320 void Ww1Manager::Pop()
321 {
322 DBG_ASSERT(Pushed(), "Ww1Manager");
323 delete pDoc;
324 pDoc = &aDoc;
325 delete pSeek;
326 pSeek = &ulDocSeek;
327 aChp.Pop();
328 aPap.Pop();
329 delete pFld;
330 pFld = &aFld;
331 }
332
333 ///////////////////////////////////////////////////////////// Bookmarks
334
335 void Ww1Bookmarks::Out(Ww1Shell& rOut, Ww1Manager& rMan, USHORT)
336 {
337 if (GetIsEnd())
338 {
339 rOut.SetBookEnd(GetHandle());
340 return;
341 }
342
343 const String & rName = GetName();
344 if( rName.EqualsAscii( "_Toc", 0, 4 ) ) // "_Toc*" ist ueberfluessig
345 return;
346
347 if( rOut.IsFlagSet( SwFltControlStack::HYPO )
348 && rName.EqualsIgnoreCaseAscii( "FORMULAR" ) )
349 rOut.SetProtect();
350
351 // Fuer UEbersetzung Bookmark -> Variable setzen
352 long nLen = Len();
353 if( nLen > MAX_FIELDLEN )
354 nLen = MAX_FIELDLEN;
355
356 // Lese Inhalt des Bookmark
357 // geht vermulich auch ueber Ww1PlainText
358 String aVal( rMan.GetText().GetText( Where(), nLen ) );
359
360 // in 2 Schritten, da OS/2 zu doof ist
361 SwFltBookmark aBook( rName, aVal, GetHandle(), FALSE );
362 rOut << aBook;
363 }
364
365 void Ww1Bookmarks::Start(Ww1Shell& rOut, Ww1Manager& rMan)
366 {
367 if (rMan.Where() >= Where())
368 {
369 Out(rOut, rMan);
370 (*this)++;
371 }
372 }
373
374 ///////////////////////////////////////////////////////////// Footnotes
375 void Ww1Footnotes::Start(Ww1Shell& rOut, Ww1Manager& rMan)
376 {
377 if (rMan.Where() >= Where())
378 {
379 DBG_ASSERT(nPlcIndex < Count(), "WwFootnotes");
380 sal_Unicode c;
381 rMan.Fill(c);
382 DBG_ASSERT(c==0x02, "Ww1Footnotes");
383 if (c==0x02)
384 {
385 Ww1FtnText* pText = new Ww1FtnText(rMan.GetFib());
386 // beginn des textes dieser fusznote:
387 ULONG start = aText.Where(nPlcIndex);
388 pText->Seek(start);
389 // laenge des textes
390 ULONG count = aText.Where(nPlcIndex+1) - start;
391 pText->SetCount(count);
392 // fusznotenkennung sollte das erste byte sein
393 pText->Out(c);
394 DBG_ASSERT(c==0x02, "Ww1Footnotes");
395 count--; // fuer das eben gelesene kenn-byte
396 // fusznoten mode beginnen:
397 rOut.BeginFootnote();
398 bStarted = TRUE;
399 rMan.Push0(pText, pText->Offset(rMan.GetFib()),
400 new Ww1FootnoteFields(rMan.GetFib()));
401 rOut << rMan;
402 rMan.Pop();
403 rOut.EndFootnote();
404 }
405 else
406 (*this)++;
407 }
408 }
409
410 void Ww1Footnotes::Stop(Ww1Shell& /*rOut*/, Ww1Manager& rMan, sal_Unicode& c)
411 {
412 if (bStarted && rMan.Where() > Where())
413 {
414 DBG_ASSERT(nPlcIndex < Count(), "Ww1Footnotes");
415 // DBG_ASSERT(c==0x02, "Ww1Footnotes"); // scheint Stuss zu sein
416 c = ' ';
417 (*this)++;
418 }
419 }
420
421 //////////////////////////////////////////////////////////////// Fields
422 void Ww1Fields::Start(Ww1Shell& rOut, Ww1Manager& rMan)
423 {
424 if (rMan.Where() >= Where()){
425 DBG_ASSERT(nPlcIndex < Count(), "Ww1Fields");
426 if (GetData()->chGet() == 19)
427 Out(rOut, rMan);
428 else
429 (*this)++; // ignore
430 }
431 }
432
433 void Ww1Fields::Stop( Ww1Shell& rOut, Ww1Manager& rMan, sal_Unicode& c)
434 {
435 if (rMan.Where() >= Where())
436 {
437 DBG_ASSERT(nPlcIndex < Count(), "Ww1Fields");
438 if (GetData()->chGet() != 19)
439 {
440 rMan.Fill( c );
441 DBG_ASSERT(c==21, "Ww1Fields");
442 (*this)++;
443 c = ' ';
444 if (pField)
445 // haben wir ein fertiges feld da, das eingefuegt werden soll?
446 {
447 rOut << *pField;
448 delete pField;
449 pField = 0;
450 // das macht der filter so, damit attribute die ueber das feld
451 // gelten auch wirklich eingelesen werden und dem feld
452 // zugeordnet werden.
453 }
454 if (sErgebnis.Len())
455 rOut << sErgebnis;
456 }
457 }
458 }
459
460 enum WWDateTime{ WW_DONTKNOW = 0x0, WW_DATE = 0x1, WW_TIME = 0x2, WW_BOTH = 0x3 };
461
462 static WWDateTime GetTimeDatePara( const String& rForm,
463 SwTimeFormat* pTime = 0,
464 SwDateFormat* pDate = 0 )
465 {
466 WWDateTime eDT = WW_BOTH;
467 if( STRING_NOTFOUND == rForm.Search( 'H' )) // H -> 24h
468 {
469 if( pTime )
470 *pTime = TF_SSMM_24;
471 }
472 else if( STRING_NOTFOUND == rForm.Search( 'H' )) // h -> 24h
473 {
474 if( pTime )
475 *pTime = TF_SSMM_12;
476 }
477 else // keine Zeit
478 {
479 eDT = (WWDateTime)( eDT & ~(USHORT)WW_TIME );
480 }
481
482 xub_StrLen nDPos = 0;
483 while( STRING_NOTFOUND != nDPos )
484 {
485 nDPos = rForm.Search( 'M', nDPos ); // M -> Datum
486 if( !nDPos )
487 break;
488 sal_Unicode cPrev = rForm.GetChar( nDPos - 1 );
489 // ignoriere dabei "AM", "aM", "PM", "pM"
490 if( 'a' != cPrev && 'A' != cPrev && 'p' != cPrev && 'P' != cPrev )
491 break;
492 // else search again
493 ++nDPos;
494 }
495
496 if( STRING_NOTFOUND != nDPos ) // Monat -> Datum ?
497 {
498 static SwDateFormat __READONLY_DATA aDateA[32] =
499 {
500 DFF_DMY, DFF_DMMY, DFF_DMYY, DFF_DMMYY,
501 DFF_DMMMY, DFF_DMMMY, DFF_DMMMYY, DFF_DMMMYY,
502 DFF_DDMMY, DFF_DDMMY, DFF_DDMMMYY, DFF_DDMMMYY,
503 DFF_DDMMMY, DFF_DDMMMY, DFF_DDMMMYY, DFF_DDMMMYY,
504 DFF_DDDMMMY, DFF_DDDMMMY, DFF_DDDMMMYY, DFF_DDDMMMYY,
505 DFF_DDDMMMY, DFF_DDDMMMY, DFF_DDDMMMYY, DFF_DDDMMMYY,
506 DFF_DDDMMMY, DFF_DDDMMMY, DFF_DDDMMMYY, DFF_DDDMMMYY,
507 DFF_DDDMMMY, DFF_DDDMMMY, DFF_DDDMMMYY, DFF_DDDMMMYY
508 };
509
510 BOOL bHasDay = STRING_NOTFOUND != rForm.Search( 't' ) ||
511 STRING_NOTFOUND != rForm.Search( 'T' ) ||
512 STRING_NOTFOUND != rForm.Search( 'd' ) ||
513 STRING_NOTFOUND != rForm.Search( 'D' );
514
515 BOOL bLongDayOfWeek= STRING_NOTFOUND != rForm.SearchAscii( "tttt" ) ||
516 STRING_NOTFOUND != rForm.SearchAscii( "TTTT" ) ||
517 STRING_NOTFOUND != rForm.SearchAscii( "dddd" ) ||
518 STRING_NOTFOUND != rForm.SearchAscii( "DDDD" );
519
520 BOOL bDayOfWeek = STRING_NOTFOUND != rForm.SearchAscii( "ttt" ) ||
521 STRING_NOTFOUND != rForm.SearchAscii( "TTT" ) ||
522 STRING_NOTFOUND != rForm.SearchAscii( "ddd" ) ||
523 STRING_NOTFOUND != rForm.SearchAscii( "DDD" );
524
525 // M, MM -> numeric month
526 // MMM, MMMM -> text. month
527 BOOL bLitMonth = STRING_NOTFOUND != rForm.SearchAscii( "MMM" );
528 // MMMM -> full month
529 BOOL bFullMonth = STRING_NOTFOUND != rForm.SearchAscii( "MMMM" );
530 // jj, JJ -> 2-col-year
531 // jjjj, JJJJ -> 4-col-year
532 BOOL bFullYear = STRING_NOTFOUND != rForm.SearchAscii( "jjj" ) ||
533 STRING_NOTFOUND != rForm.SearchAscii( "JJJ" ) ||
534 STRING_NOTFOUND != rForm.SearchAscii( "yyy" ) ||
535 STRING_NOTFOUND != rForm.SearchAscii( "YYY" );
536
537 USHORT i = ( bLitMonth & 1 )
538 | ( ( bFullYear & 1 ) << 1 )
539 | ( ( bFullMonth & 1 ) << 2 )
540 | ( ( bDayOfWeek & 1 ) << 3 )
541 | ( ( bLongDayOfWeek & 1 ) << 4 );
542 if( pDate )
543 {
544 if( !bHasDay && !bFullMonth )
545 *pDate = DFF_MY;
546 else
547 *pDate = aDateA[i];
548 }
549 }
550 else
551 {
552 eDT = (WWDateTime)( eDT & ~(USHORT)WW_DATE );
553 }
554 return eDT;
555 }
556
557
558 extern void sw3io_ConvertFromOldField( SwDoc& rDoc, USHORT& rWhich,
559 USHORT& rSubType, ULONG &rFmt,
560 USHORT nVersion );
561
562 void Ww1Fields::Out(Ww1Shell& rOut, Ww1Manager& rMan, USHORT nDepth)
563 {
564 String sType; // der typ als string
565 String sFormel; // die formel
566 String sFormat;
567 String sDTFormat; // Datum / Zeit-Format
568 W1_FLD* pData = GetData(); // die an den plc gebunden daten
569 DBG_ASSERT(pData->chGet()==19, "Ww1Fields"); // sollte beginn sein
570
571 sal_Unicode c;
572 rMan.Fill( c );
573 DBG_ASSERT(c==19, "Ww1Fields"); // sollte auch beginn sein
574 if (pData->chGet()==19 && c == 19)
575 {
576 String aStr;
577 c = rMan.Fill( aStr, GetLength() );
578 DBG_ASSERT(Ww1PlainText::IsChar(c), "Ww1Fields");
579 xub_StrLen pos = aStr.Search(' ');
580 // get type out of text
581 sType = aStr.Copy( 0, pos );
582 aStr.Erase( 0, pos );
583 if ( pos != STRING_NOTFOUND )
584 aStr.Erase(0, 1);
585 sFormel += aStr;
586 BYTE rbType = pData->fltGet();
587 do {
588 // solange den formelteil einlesen, bis das feld entweder
589 // zuende ist oder der ergebnisteil beginnt. dabei koennen
590 // natuerlich neue felder beginnen (word unterstuetzt felder,
591 // die wiederum felder beinhalten).
592 (*this)++;
593 pData = GetData();
594 if (pData->chGet()==19) // nested field
595 {
596 Out(rOut, rMan, nDepth+1);
597 rMan.Fill(c);
598 DBG_ASSERT(c==21, "Ww1PlainText");
599 sFormel.AppendAscii( RTL_CONSTASCII_STRINGPARAM( "Ww" ));
600 sFormel += String::CreateFromInt32( nPlcIndex );
601 c = rMan.Fill(aStr, GetLength());
602 DBG_ASSERT(Ww1PlainText::IsChar(c), "Ww1PlainText");
603 sFormel += aStr;
604 }
605 }
606 while (pData->chGet()==19);
607
608 // get format out of text
609 pos = sFormel.SearchAscii( "\\*" );
610 sFormat = sFormel.Copy( pos );
611 sFormel.Erase( pos );
612
613 pos = sFormel.SearchAscii( "\\@" );
614 sDTFormat = sFormel.Copy( pos );
615 sFormel.Erase( pos );
616
617 // der formelteil ist zuende, kommt ein ergebnisteil?
618 if( pData->chGet() == 20 )
619 {
620 rMan.Fill( c );
621 DBG_ASSERT(c==20, "Ww1PlainText");
622 c = rMan.Fill(sErgebnis, GetLength());
623 if (!Ww1PlainText::IsChar(c))
624 sErgebnis += c; //~ mdt: sonderzeichenbenhandlung
625 (*this)++;
626 pData = GetData();
627 }
628 DBG_ASSERT(pData->chGet()==21, "Ww1PlainText");
629 BOOL bKnown = TRUE;
630 DBG_ASSERT(pField==0, "Ww1PlainText");
631 if (pField != 0)
632 {
633 rOut << *pField;
634 delete pField;
635 pField = 0;
636 }
637 // naja, aber info enthaelt alle moeglichkeiten, die auch direkt da sind
638 oncemore:
639 switch (rbType)
640 {
641 case 3: // bookmark reference
642 rOut.ConvertUStr( sFormel );
643 pField = new SwGetRefField( (SwGetRefFieldType*)
644 rOut.GetSysFldType( RES_GETREFFLD ),
645 sFormel,
646 REF_BOOKMARK,
647 0,
648 REF_CONTENT );
649 // pField = new SwGetExpField((SwGetExpFieldType*)
650 // rOut.GetSysFldType(RES_GETEXPFLD), sFormel, nsSwGetSetExpType::GSE_STRING);
651 // ,
652 // nsSwGetSetExpType::GSE_STRING, VVF_SYS);
653 break;
654 case 6: // set command
655 {
656 pos = aStr.Search(' ');
657 String aName( aStr.Copy( 0, pos ));
658 aStr.Erase(0, pos );
659 aStr.Erase(0, 1);
660 if( !aName.Len() )
661 break;
662 rOut.ConvertUStr( aName );
663 SwFieldType* pFT = rOut.GetDoc().InsertFldType(
664 SwSetExpFieldType( &rOut.GetDoc(), aName, nsSwGetSetExpType::GSE_STRING ) );
665 pField = new SwSetExpField((SwSetExpFieldType*)pFT, aStr);
666 ((SwSetExpField*)pField)->SetSubType( nsSwExtendedSubType::SUB_INVISIBLE );
667 // Invisible macht in 378 AErger, soll aber demnaechst gehen
668
669 // das Ignorieren des Bookmarks ist nicht implementiert
670 }
671 break;
672 case 14: // info var
673 {
674 pos = aStr.Search(' ');
675 String aSubType( aStr.Copy( 0, pos ));
676 aStr.Erase(0, pos );
677 aStr.Erase(0, 1);
678 rOut.ConvertUStr( aSubType );
679
680
681 // ganz grosze schiete: der typ 'info' kann einem der
682 // typen 15..31 entsprechen. er enthaelt als formel
683 // das eingentliche feld der doc-info.
684 // kein ';' benutzen mit folgendem macro:
685 #define IS(sd, se, t) \
686 if (aSubType.EqualsAscii( sd ) || aSubType.EqualsAscii( se)) \
687 rbType = t; \
688 else
689
690 // deutsche bez. englische bez. typ-code
691 IS("titel", "title", 15)
692 IS("thema", "subject", 16)
693 IS("autor", "author", 17)
694 IS("stichw?rter", "keywords", 18) //~ mdt: umlaut
695 IS("kommentar", "comment", 19)
696 IS("gespeichertvon", "lastrevisedby", 20)
697 IS("ertelldat", "creationdate", 21)
698 IS("speicherdat", "revisiondate", 22)
699 IS("druckdat", "printdate", 23)
700 IS("version", "revisionnumber", 24)
701 IS("zeit", "edittime", 25)
702 IS("anzseit", "numberofpages", 26)
703 IS("anzw?rter", "numberofwords", 27) //~ mdt: umlaut
704 IS("anzzeichen", "numberofchars", 28)
705 IS("dateiname", "filename", 29)
706 IS("vorlage", "templatename", 30)
707 bKnown = FALSE;
708 #undef IS
709 if (rbType != 14)
710 goto oncemore;
711 }
712 break;
713 case 15: // title
714 pField = new SwDocInfoField((SwDocInfoFieldType*)
715 rOut.GetSysFldType(RES_DOCINFOFLD), DI_TITEL, String(), 0);
716 break;
717 case 16: // subject
718 pField = new SwDocInfoField((SwDocInfoFieldType*)
719 rOut.GetSysFldType(RES_DOCINFOFLD), DI_THEMA, String(), 0);
720 break;
721 case 17: // author
722 pField = new SwAuthorField((SwAuthorFieldType*)
723 rOut.GetSysFldType(RES_AUTHORFLD), AF_NAME );
724 break;
725 case 18: // keywords
726 pField = new SwDocInfoField((SwDocInfoFieldType*)
727 rOut.GetSysFldType(RES_DOCINFOFLD), DI_KEYS, String(), 0);
728 break;
729 case 19: // comments
730 pField = new SwDocInfoField((SwDocInfoFieldType*)
731 rOut.GetSysFldType(RES_DOCINFOFLD), DI_COMMENT, String(), 0);
732 break;
733 case 20: // last revised by
734 pField = new SwDocInfoField((SwDocInfoFieldType*)
735 rOut.GetSysFldType(RES_DOCINFOFLD), DI_CHANGE|DI_SUB_AUTHOR, String());
736 break;
737 case 21: // creation date
738 case 22: // revision date
739 case 23: // print date
740 case 25:{// edit time
741 USHORT nSub;
742 USHORT nReg = 0; // RegInfoFormat, DefaultFormat fuer DocInfoFelder
743
744 switch( rbType )
745 {
746 default:
747 case 21: nSub = DI_CREATE; nReg = DI_SUB_DATE; break;
748 case 23: nSub = DI_PRINT; nReg = DI_SUB_DATE; break;
749 case 22: nSub = DI_CHANGE; nReg = DI_SUB_DATE; break;
750 case 25: nSub = DI_CHANGE; nReg = DI_SUB_TIME; break;
751 }
752 switch( GetTimeDatePara( sDTFormat ) )
753 {
754 case WW_DATE: nReg = DI_SUB_DATE; break;
755 case WW_TIME: nReg = DI_SUB_TIME; break;
756 case WW_BOTH: nReg = DI_SUB_DATE; break;
757 default:
758 break;
759 // WW_DONTKNOW -> Default bereits gesetzt
760 }
761 pField = new SwDocInfoField((SwDocInfoFieldType*)
762 rOut.GetSysFldType(RES_DOCINFOFLD), nSub | nReg, String());
763 }
764 break;
765 case 24: // revision number
766 pField = new SwDocInfoField((SwDocInfoFieldType*)
767 rOut.GetSysFldType(RES_DOCINFOFLD), DI_DOCNO, String(), 0);
768 break;
769 case 26: // number of pages
770 pField = new SwDocStatField((SwDocStatFieldType*)
771 rOut.GetSysFldType(RES_DOCSTATFLD), DS_PAGE, SVX_NUM_ARABIC);
772 break;
773 case 27: // number of words
774 pField = new SwDocStatField((SwDocStatFieldType*)
775 rOut.GetSysFldType(RES_DOCSTATFLD), DS_WORD, SVX_NUM_ARABIC);
776 break;
777 case 28: // number of chars
778 pField = new SwDocStatField((SwDocStatFieldType*)
779 rOut.GetSysFldType(RES_DOCSTATFLD), DS_CHAR, SVX_NUM_ARABIC);
780 break;
781 case 29: // file name
782 pField = new SwFileNameField((SwFileNameFieldType*)
783 rOut.GetSysFldType(RES_FILENAMEFLD));
784 break;
785 case 30: // doc template name
786 pField = new SwTemplNameField((SwTemplNameFieldType*)
787 rOut.GetSysFldType(RES_TEMPLNAMEFLD), FF_NAME);
788 break;
789 case 31:
790 case 32:{
791 SwDateFormat aDate = DF_SSYS;
792 SwTimeFormat aTime = TF_SYSTEM;
793
794 WWDateTime eDT = GetTimeDatePara(sDTFormat, &aTime, &aDate);
795 if( eDT == WW_DONTKNOW ) // kein D/T-Formatstring
796 eDT = ( rbType == 32 ) ? WW_TIME : WW_DATE; // benutze ID
797
798 if( eDT & WW_DATE )
799 {
800 USHORT nWhich = RES_DATEFLD;
801 USHORT nSubType = DATEFLD;
802 ULONG nFormat = aDate;
803 sw3io_ConvertFromOldField( rOut.GetDoc(),
804 nWhich, nSubType, nFormat, 0x0110 );
805 pField = new SwDateTimeField((SwDateTimeFieldType*)
806 rOut.GetSysFldType(RES_DATETIMEFLD), DATEFLD, nFormat);
807
808 if( eDT == WW_BOTH )
809 rOut << * pField << ' ';
810 // Mogel: direkt einfuegen und Space dahinter
811 }
812 if( eDT & WW_TIME )
813 {
814 USHORT nWhich = RES_TIMEFLD;
815 USHORT nSubType = TIMEFLD;
816 ULONG nFormat = aTime;
817 sw3io_ConvertFromOldField( rOut.GetDoc(),
818 nWhich, nSubType, nFormat, 0x0110 );
819 pField = new SwDateTimeField((SwDateTimeFieldType*)
820 rOut.GetSysFldType(RES_DATETIMEFLD), TIMEFLD, nFormat);
821 }
822
823 }
824 break;
825 case 33: // current page
826 pField = new SwPageNumberField((SwPageNumberFieldType*)
827 rOut.GetSysFldType(RES_PAGENUMBERFLD), PG_RANDOM, SVX_NUM_ARABIC);
828 break;
829 case 34: // evaluation exp
830 {
831 if (nDepth == 0)
832 {
833 SwGetExpFieldType* pFieldType =
834 (SwGetExpFieldType*)rOut.GetSysFldType(RES_GETEXPFLD);
835 DBG_ASSERT(pFieldType!=0, "Ww1Fields");
836 if (pFieldType != 0)
837 pField = new SwGetExpField(pFieldType, sFormel,
838 nsSwGetSetExpType::GSE_STRING, VVF_SYS);
839 }
840 else // rekursion:
841 {
842 String aName( String::CreateFromAscii(
843 RTL_CONSTASCII_STRINGPARAM( "Ww" )));
844 aName += String::CreateFromInt32( nPlcIndex );
845 SwFieldType* pFT = rOut.GetDoc().GetFldType( RES_SETEXPFLD, aName, false);
846 if (pFT == 0)
847 {
848 SwSetExpFieldType aS(&rOut.GetDoc(), aName, nsSwGetSetExpType::GSE_FORMULA);
849 pFT = rOut.GetDoc().InsertFldType(aS);
850 }
851 SwSetExpField aFld((SwSetExpFieldType*)pFT, sFormel);
852 aFld.SetSubType(nsSwExtendedSubType::SUB_INVISIBLE);
853 rOut << aFld;
854 }
855 }
856 break;
857 case 36: // print command, Einfuegendatei
858 {
859 pos = aStr.Search(' ');
860 String aFName( aStr.Copy( 0, pos ));
861 aStr.Erase(0, pos );
862 aStr.Erase(0, 1);
863 if( !aFName.Len() )
864 break;
865 aFName.SearchAndReplaceAscii( "\\\\", String( '\\' ));
866
867 // char* pBook = FindNextPara( pNext, 0 ); //!! Bookmark/Feld-Name
868 // //!! erstmal nicht
869
870 // ConvertFFileName( aPara, pFName ); //!! WW1 ????
871 aFName = URIHelper::SmartRel2Abs(
872 INetURLObject(rOut.GetBaseURL()), aFName );
873
874 String aName( String::CreateFromAscii(
875 RTL_CONSTASCII_STRINGPARAM( "WW" )));
876 SwSection* pSection = new SwSection( FILE_LINK_SECTION,
877 rOut.GetDoc().GetUniqueSectionName( &aStr ) );
878 pSection->SetLinkFileName( aFName );
879 pSection->SetProtect( TRUE );
880 rOut << SwFltSection( pSection );
881 rOut.EndItem( RES_FLTR_SECTION );
882 rOut.NextParagraph();
883 }
884 case 37: // page ref
885 pField = new SwGetRefField(
886 (SwGetRefFieldType*)rOut.GetSysFldType(RES_GETREFFLD),
887 sFormel, 0, 0, REF_PAGE);
888 break;
889 case 38: // ask command
890 {
891 pos = aStr.Search(' ');
892 String aName( aStr.Copy( 0, pos ));
893 aStr.Erase(0, pos );
894 aStr.Erase(0, 1);
895 if( !aName.Len() )
896 break;
897
898 SwFieldType* pFT = rOut.GetDoc().InsertFldType(
899 SwSetExpFieldType( &rOut.GetDoc(), aName, nsSwGetSetExpType::GSE_STRING ) );
900 pField = new SwSetExpField((SwSetExpFieldType*)pFT, aStr );
901 ((SwSetExpField*)pField)->SetInputFlag( TRUE );
902 ((SwSetExpField*)pField)->SetSubType(nsSwExtendedSubType::SUB_INVISIBLE);
903 // pField.SetPromptText( aQ ); //!! fehlt noch
904 // aFld.SetPar2( aDef ); //!! dito
905 // das Ignorieren des Bookmarks ist nicht implementiert
906 }
907 case 39: // fillin command
908 pField = new SwInputField(
909 (SwInputFieldType*)rOut.GetSysFldType( RES_INPUTFLD ),
910 aEmptyStr, sFormel,
911 INP_TXT, 0 ); // sichtbar ( geht z.Zt. nicht anders )
912 break;
913 case 51: // macro button
914 {
915 pos = aStr.Search(' ');
916 String aName( aStr.Copy( 0, pos ));
917 aStr.Erase(0, pos );
918 aStr.Erase(0, 1);
919 if( !aName.Len() || !aStr.Len() )
920 break;
921 aName.InsertAscii( "StarOffice.Standard.Modul1.", 0 );
922
923 pField = new SwMacroField( (SwMacroFieldType*)
924 rOut.GetSysFldType( RES_MACROFLD ),
925 aName, aStr );
926 }
927 break;
928 case 55: // read tiff / or better: import anything
929 {
930 const sal_Unicode* pFormel = sFormel.GetBuffer();
931 const sal_Unicode* pDot = 0;
932 String sName;
933 while (*pFormel != '\0' && *pFormel != ' ')
934 {
935 // ab hier koennte eine extension kommen
936 if (*pFormel == '.')
937 pDot = pFormel;
938 else
939 // aha: wir waren bislang noch in dirs
940 if (*pFormel == '\\')
941 {
942 pDot = 0;
943 if (pFormel[1] == '\\')
944 pFormel++;
945 }
946 if (*pFormel != '\0')
947 sName += *pFormel++;
948 }
949 if( pDot )
950 {
951 String sExt;
952 while( *pDot != '\0' && *pDot != ' ')
953 sExt += *pDot++;
954
955 if( sExt.EqualsIgnoreCaseAscii( ".tiff" )
956 || sExt.EqualsIgnoreCaseAscii( ".bmp" )
957 || sExt.EqualsIgnoreCaseAscii( ".gif" )
958 || sExt.EqualsIgnoreCaseAscii( ".pcx" )
959 || sExt.EqualsIgnoreCaseAscii( ".pic" ))
960 rOut.AddGraphic( sName );
961 else
962 bKnown = FALSE;
963 }
964 else
965 bKnown = FALSE;
966 }
967 break;
968 default: // unknown
969 DBG_ASSERT(FALSE, "Ww1PlainText");
970 // unsupported:
971 case 1: // unknown
972 case 2: // possible bookmark
973 case 4: // index entry
974 // wwpar5: 1351/1454
975 case 5: // footnote ref
976 // pField = new SwGetRefField(
977 // (SwGetRefFieldType*)rDoc.GetSysFldType(RES_GETREFFLD),
978 // sFormel, REF_FOOTNOTE, 0, REF_BEGIN);
979 case 7: // if command
980 case 8: // create index
981 // wwpar5: 1351/1454
982 case 9: // table of contents entry
983 // wwpar5: 1351/1454
984 case 10: // style ref
985 case 11: // doc ref
986 case 12: // seq ref
987 case 13: // create table of contents
988 // wwpar5: 1351/1454
989 case 35: // literal text
990 // print merge:
991 case 40: // data command
992 case 41: // next command
993 case 42: // nextif command
994 case 43: // skipif command
995 case 44: // number of record
996 //
997 case 45: // dde ref
998 case 46: // dde auto ref
999 case 47: // glossary entry
1000 case 48: // print char
1001 case 49: // formula def
1002 case 50: // goto button
1003 case 52: // auto number outline
1004 case 53: // auto number legal
1005 case 54: // auto number arabic
1006 bKnown = FALSE;
1007 break;
1008 }
1009 if( bKnown || sErgebnis.EqualsAscii( "\270" ))
1010 this->sErgebnis.Erase();
1011 else
1012 this->sErgebnis = sErgebnis;
1013 }
1014 else // oops: we are terribly wrong: skip this
1015 (*this)++;
1016 }
1017
1018 ULONG Ww1Fields::GetLength()
1019 {
1020 // berechnet die laenge eines feldteiles. nicht mitgerechnet werden
1021 // die terminierenden zeichen im text (19, 20, 21) die beginn, trenner
1022 // und ende bedeuten.
1023 ULONG ulBeg = Where();
1024 ULONG ulEnd = Where(nPlcIndex+1);
1025 DBG_ASSERT(ulBeg<ulEnd, "Ww1Fields");
1026 return (ulEnd - ulBeg) - 1;
1027 }
1028
1029 /////////////////////////////////////////////////////////////////// Sep
1030 void Ww1Sep::Start(Ww1Shell& rOut, Ww1Manager& rMan)
1031 {
1032 if (rMan.Where() >= Where())
1033 {
1034 rOut.NextSection();
1035 SwFrmFmt &rFmt = rOut.GetPageDesc().GetMaster();
1036 W1_DOP& rDOP = rMan.GetDop().GetDOP();
1037 rOut.GetPageDesc().SetLandscape(rDOP.fWideGet());
1038 SwFmtFrmSize aSz(rFmt.GetFrmSize());
1039 aSz.SetWidth(rDOP.xaPageGet());
1040 aSz.SetHeight(rDOP.yaPageGet());
1041 rFmt.SetFmtAttr(aSz);
1042 SvxLRSpaceItem aLR(rDOP.dxaLeftGet()+rDOP.dxaGutterGet(),
1043 rDOP.dxaRightGet(), 0, 0, RES_LR_SPACE);
1044 rFmt.SetFmtAttr(aLR);
1045 SvxULSpaceItem aUL(rDOP.dyaTopGet(), rDOP.dyaBottomGet(), RES_UL_SPACE);
1046 rFmt.SetFmtAttr(aUL);
1047 // sobald wir mit dem lesen der zeichen soweit sind, wo sep's
1048 // momentanes attribut beginnt, wird dieses attribut eingefuegt.
1049 // diese methode ist bei den meisten start/stop methoden der
1050 // memberklassen des managers identisch.
1051 BYTE* pByte = GetData();
1052 Ww1SprmSep aSprm(rFib, SVBT32ToUInt32(pByte + 2));
1053 aSprm.Start(rOut, rMan);
1054 aSprm.Stop(rOut, rMan);
1055 (*this)++;
1056 aHdd.Start(rOut, rMan);
1057 }
1058 }
1059
1060 /////////////////////////////////////////////////////////////////// Pap
1061 void Ww1Pap::Start(Ww1Shell& rOut, Ww1Manager& rMan)
1062 {
1063 if (rMan.Where() >= Where())
1064 {
1065 BYTE* pByte;
1066 USHORT cb;
1067 // bereitstellen der zu startenden attribute
1068 if (FillStart(pByte, cb))
1069 {
1070 Ww1SprmPapx aSprm(pByte, cb);
1071 // und ausgeben:
1072 aSprm.Start(rOut, rMan);
1073 }
1074 (*this)++;
1075 }
1076 }
1077
1078 void Ww1Pap::Stop(Ww1Shell& rOut, Ww1Manager& rMan, sal_Unicode&)
1079 {
1080 if (rMan.Where() >= Where() || rMan.IsStopAll())
1081 {
1082 BYTE* pByte;
1083 USHORT cb;
1084 if (FillStop(pByte, cb)){
1085 Ww1SprmPapx aSprm(pByte, cb);
1086 aSprm.Stop(rOut, rMan);
1087 }else{
1088 DBG_ASSERT( !nPlcIndex || rMan.IsStopAll(), "Pap-Attribut-Stop verloren" );
1089 // rMan.IsStopAll() ist nicht schoen.
1090 }
1091 }
1092 }
1093
1094 //////////////////////////////////////////////////////////////// W1_CHP
1095 //
1096 // momentan laesst sich die ausgabe von W1CHPxen nicht nur per define
1097 // loesen....
1098 //
1099 void W1_CHP::Out(Ww1Shell& rOut, Ww1Manager& rMan)
1100 {
1101 if (fBoldGet())
1102 rOut << SvxWeightItem(
1103 rOut.GetWeightBold()?WEIGHT_NORMAL:WEIGHT_BOLD, RES_CHRATR_WEIGHT);
1104 if (fItalicGet())
1105 rOut << SvxPostureItem(
1106 rOut.GetPostureItalic()?ITALIC_NONE:ITALIC_NORMAL, RES_CHRATR_POSTURE);
1107 if (fStrikeGet())
1108 rOut << SvxCrossedOutItem(
1109 rOut.GetCrossedOut()?STRIKEOUT_NONE:STRIKEOUT_SINGLE, RES_CHRATR_CROSSEDOUT);
1110 if (fOutlineGet())
1111 rOut << SvxContourItem(!rOut.GetContour(), RES_CHRATR_CONTOUR);
1112 if (fSmallCapsGet())
1113 rOut << SvxCaseMapItem(
1114 rOut.GetCaseKapitaelchen()?SVX_CASEMAP_NOT_MAPPED:SVX_CASEMAP_KAPITAELCHEN, RES_CHRATR_CASEMAP);
1115 if (fCapsGet())
1116 rOut << SvxCaseMapItem(
1117 rOut.GetCaseVersalien()?SVX_CASEMAP_NOT_MAPPED:SVX_CASEMAP_VERSALIEN, RES_CHRATR_CASEMAP);
1118 if (fsHpsGet())
1119 rOut << SvxFontHeightItem(hpsGet() * 10, 100, RES_CHRATR_FONTSIZE);
1120 if (fsKulGet())
1121 switch (kulGet()) {
1122 case 0: {
1123 rOut << SvxUnderlineItem(UNDERLINE_NONE, RES_CHRATR_UNDERLINE) <<
1124 SvxWordLineModeItem(FALSE, RES_CHRATR_WORDLINEMODE);
1125 } break;
1126 default: DBG_ASSERT(FALSE, "Chpx");
1127 case 1: {
1128 rOut << SvxUnderlineItem(UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE);
1129 } break;
1130 case 2: {
1131 rOut << SvxUnderlineItem(UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE) <<
1132 SvxWordLineModeItem(TRUE, RES_CHRATR_WORDLINEMODE);
1133 } break;
1134 case 3: {
1135 rOut << SvxUnderlineItem(UNDERLINE_DOUBLE, RES_CHRATR_UNDERLINE);
1136 } break;
1137 case 4: {
1138 rOut << SvxUnderlineItem(UNDERLINE_DOTTED, RES_CHRATR_UNDERLINE);
1139 } break;
1140 }
1141
1142 if (fsIcoGet())
1143 switch(icoGet()) {
1144 default: DBG_ASSERT(FALSE, "Chpx");
1145 case 0: { rOut.EndItem(RES_CHRATR_COLOR); } break;
1146 case 1: { rOut << SvxColorItem(Color(COL_BLACK), RES_CHRATR_COLOR); } break;
1147 case 2: { rOut << SvxColorItem(Color(COL_LIGHTBLUE), RES_CHRATR_COLOR); } break;
1148 case 3: { rOut << SvxColorItem(Color(COL_LIGHTCYAN), RES_CHRATR_COLOR); } break;
1149 case 4: { rOut << SvxColorItem(Color(COL_LIGHTGREEN), RES_CHRATR_COLOR); } break;
1150 case 5: { rOut << SvxColorItem(Color(COL_LIGHTMAGENTA), RES_CHRATR_COLOR); } break;
1151 case 6: { rOut << SvxColorItem(Color(COL_LIGHTRED), RES_CHRATR_COLOR); } break;
1152 case 7: { rOut << SvxColorItem(Color(COL_YELLOW), RES_CHRATR_COLOR); } break;
1153 case 8: { rOut << SvxColorItem(Color(COL_WHITE), RES_CHRATR_COLOR); } break;
1154 }
1155 if (fsSpaceGet()) {
1156 short sQps = qpsSpaceGet();
1157 if (sQps > 56)
1158 sQps = sQps - 64;
1159 rOut << SvxKerningItem(sQps, RES_CHRATR_KERNING);
1160 }
1161 if (fsPosGet()) {
1162 if (hpsPosGet() == 0)
1163 rOut << SvxEscapementItem(SVX_ESCAPEMENT_OFF, 100, RES_CHRATR_ESCAPEMENT);
1164 else {
1165 short sHps = hpsPosGet();
1166 if (sHps > 128)
1167 sHps = sHps - 256;
1168 sHps *= 100;
1169 sHps /= 24;
1170 rOut << SvxEscapementItem(sHps, 100, RES_CHRATR_ESCAPEMENT);
1171 }
1172 }
1173 if (fsFtcGet()) {
1174 SvxFontItem aFont(rMan.GetFont(ftcGet()));
1175 rOut << aFont;
1176 }
1177 }
1178
1179 /////////////////////////////////////////////////////////////////// Chp
1180 void Ww1Chp::Start(Ww1Shell& rOut, Ww1Manager& rMan)
1181 {
1182 if (rMan.Where() >= Where())
1183 {
1184 W1_CHP aChpx;
1185 if (FillStart(aChpx))
1186 {
1187 aChpx.Out(rOut, rMan);
1188 if (aChpx.fcPicGet())
1189 {
1190 Ww1Picture aPic(rMan.GetFib().GetStream(),
1191 aChpx.fcPicGet());
1192 if (!aPic.GetError())
1193 aPic.Out(rOut, rMan);
1194 }
1195 }
1196 (*this)++;
1197 }
1198 }
1199
1200 void Ww1Chp::Stop(Ww1Shell& rOut, Ww1Manager& rMan, sal_Unicode&)
1201 {
1202 if (rMan.Where() >= Where())
1203 {
1204 W1_CHP aChpx;
1205 if (FillStop(aChpx))
1206 {
1207 // zuerst alle toggle-flags
1208 if (aChpx.fBoldGet())
1209 rOut.EndItem(RES_CHRATR_WEIGHT);
1210 if (aChpx.fItalicGet())
1211 rOut.EndItem(RES_CHRATR_POSTURE);
1212 if (aChpx.fStrikeGet())
1213 rOut.EndItem(RES_CHRATR_CROSSEDOUT);
1214 if (aChpx.fOutlineGet())
1215 rOut.EndItem(RES_CHRATR_CONTOUR);
1216 if (aChpx.fSmallCapsGet() || aChpx.fCapsGet())
1217 rOut.EndItem(RES_CHRATR_CASEMAP);
1218 // dann alle zahl-werte, diese haben flags, wenn sie gesetzt
1219 // sind..................
1220 if (aChpx.fsHpsGet())
1221 rOut.EndItem(RES_CHRATR_FONTSIZE);
1222 if (aChpx.fsKulGet())
1223 rOut.EndItem(RES_CHRATR_UNDERLINE)
1224 .EndItem(RES_CHRATR_WORDLINEMODE);
1225 if (aChpx.fsIcoGet())
1226 rOut.EndItem(RES_CHRATR_COLOR);
1227 if (aChpx.fsSpaceGet())
1228 rOut.EndItem(RES_CHRATR_KERNING);
1229 if (aChpx.fsPosGet())
1230 rOut.EndItem(RES_CHRATR_ESCAPEMENT);
1231 if (aChpx.fsFtcGet())
1232 rOut.EndItem(RES_CHRATR_FONT);
1233 }else{
1234 DBG_ASSERT( !nPlcIndex, "Chp-Attribut-Stop verloren" );
1235 }
1236 }
1237 }
1238
1239 ///////////////////////////////////////////////////////////////// Style
1240 void Ww1Style::Out(Ww1Shell& rOut, Ww1Manager& rMan)
1241 {
1242 // Zuerst Basis, damit Attribute des Basis-Styles erkannt werden
1243 // first: Base................................................
1244 if(pParent->GetStyle(stcBase).IsUsed() ) // Basis gueltig ?
1245 rOut.BaseStyle(stcBase);
1246
1247 // next of all: CHP...............................................
1248 aChpx.Out(rOut, rMan);
1249 // Last: PAP.......................................................
1250 if (pPapx)
1251 pPapx->Start(rOut, rMan);
1252 }
1253
1254 ////////////////////////////////////////////////////////// Ww1PlainText
1255 //
1256 // die Out() methoden von plaintext fuer den filter geben eine anzahl
1257 // zeichen aus auf die shell, einen string oder einen char, wieviel
1258 // zeichen ausgegeben werden, bestimmt ulEnd, das das ende bestimmt,
1259 // bis zudem ausgegeben wird. ausserdem beenden die methoden die
1260 // ausgabe bei kontrollzeichen.
1261 // diese sind definiert durch MinChar. alle zeichen mit wert darunter
1262 // gelten als kontroll- zeichen. dafuer gibts die methode IsChar, die
1263 // zurueckgibt, ob es sich um ein standard zeichen handelt. kommt ein
1264 // solches zeichen, wird dieses zeichen zurueckgegeben und die methode
1265 // beendet, auch wenn ulEnd noch nicht erreicht wurde. bei nutzung
1266 // also beachten, dasz wenn !IsChar(Out(...)) gilt, ulEnd unter
1267 // umstaenden nicht erreicht wurde. dann wurde das kontrollzeichen
1268 // zwar (weg-)gelesen, jedoch noch nicht ausgegeben.
1269 //
1270 sal_Unicode Ww1PlainText::Out( Ww1Shell& rOut, ULONG& ulEnd )
1271 {
1272 // gibt die zeichen bis ulEnd aus, es sei den es kommen sonderzeichen
1273 // die eine bedeutung haben wie absatzende oder seitenumbruch.
1274 if (ulEnd > Count())
1275 ulEnd = Count();
1276 while (ulSeek < ulEnd)
1277 {
1278 sal_Unicode c = (*this)[ulSeek];
1279 (*this)++;
1280 if (Ww1PlainText::IsChar(c))
1281 rOut << c;
1282 else
1283 return c;
1284 }
1285 return Ww1PlainText::MinChar;
1286 }
1287
1288 sal_Unicode Ww1PlainText::Out( String& rStr, ULONG ulEnd )
1289 {
1290 // wie Out(Shell..., jedoch ausgabe auf einen string
1291 rStr.Erase();
1292 if (ulEnd > Count())
1293 ulEnd = Count();
1294 while (ulSeek < ulEnd)
1295 {
1296 sal_Unicode c = (*this)[ulSeek];
1297 (*this)++;
1298 if( Ww1PlainText::IsChar(c) )
1299 rStr += c;
1300 else
1301 return c;
1302 }
1303 return Ww1PlainText::MinChar;
1304 }
1305
1306 //
1307 // hier eruebrigt sich ulEnd...oder?
1308 //
1309 sal_Unicode Ww1PlainText::Out( sal_Unicode& rRead )
1310 {
1311 rRead = (*this)[ulSeek];
1312 (*this)++;
1313 return rRead;
1314 }
1315
1316 /////////////////////////////////////////////////////////// Ww1SprmPapx
1317
1318 void Ww1SprmPapx::Start(Ww1Shell& rOut, Ww1Manager& rMan)
1319 {
1320 if( !rMan.IsInStyle() ){ // Innerhalb Style gehts ueber die
1321 // normalen Attribute
1322 if (!rOut.IsInFly()
1323 && !rOut.IsInTable() // Nicht innerhalb Tabelle!
1324 && ( rMan.HasPPc() || rMan.HasPDxaAbs())){ // Fly-Start
1325 rOut.BeginFly(); // eAnchor );
1326 }
1327 if (!rOut.IsInTable() && rMan.HasInTable())
1328 {
1329 rOut.BeginTable();
1330 }
1331 rOut.SetStyle(aPapx.stcGet());
1332 }
1333 Ww1Sprm::Start(rOut, rMan);
1334 }
1335
1336 void Ww1SprmPapx::Stop(Ww1Shell& rOut, Ww1Manager& rMan)
1337 {
1338 Ww1Sprm::Stop(rOut, rMan);
1339
1340 if( !rMan.IsInStyle() ) // Innerhalb Style gehts ueber die
1341 { // normalen Attribute
1342 if (rOut.IsInTable() &&( rMan.IsStopAll() || !rMan.HasInTable()))
1343 rOut.EndTable();
1344
1345 if( rOut.IsInFly() &&
1346 ( rMan.IsStopAll()
1347 || ( !rMan.HasPPc() && !rMan.HasPDxaAbs() // Fly-Ende
1348 && !rOut.IsInTable()))) // Nicht innerhalb Tabelle!
1349 rOut.EndFly();
1350 }
1351 }
1352
1353 ///////////////////////////////////////////////////////////////// Fonts
1354 SvxFontItem Ww1Fonts::GetFont(USHORT nFCode)
1355 {
1356 // erzeugen eine fonts im sw-sinne aus den word-strukturen
1357 FontFamily eFamily = FAMILY_DONTKNOW;
1358 String aName;
1359 FontPitch ePitch = PITCH_DONTKNOW;
1360 rtl_TextEncoding eCharSet = RTL_TEXTENCODING_DONTKNOW;
1361 switch (nFCode)
1362 {
1363 // In the Winword 1.x format, the names of the first three fonts were
1364 // omitted from the table and assumed to be "Tms Rmn" (for ftc = 0),
1365 // "Symbol", and "Helv"
1366 case 0:
1367 eFamily = FAMILY_ROMAN;
1368 aName.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Tms Rmn" ));
1369 ePitch = PITCH_VARIABLE;
1370 eCharSet = RTL_TEXTENCODING_MS_1252;
1371 break;
1372 case 1:
1373 aName.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Symbol" ));
1374 ePitch = PITCH_VARIABLE;
1375 eCharSet = RTL_TEXTENCODING_SYMBOL;
1376 break;
1377 case 2:
1378 eFamily = FAMILY_SWISS;
1379 aName.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Helv" ));
1380 ePitch = PITCH_VARIABLE;
1381 eCharSet = RTL_TEXTENCODING_MS_1252;
1382 break;
1383 default:
1384 {
1385 W1_FFN* pF = GetFFN(nFCode - 3);
1386 if (pF != 0)
1387 {
1388 // Fontname .........................................
1389 aName = String( (sal_Char*)pF->szFfnGet(),
1390 RTL_TEXTENCODING_MS_1252 );
1391 // Pitch .............................................
1392 static FontPitch ePitchA[] =
1393 {
1394 PITCH_DONTKNOW, PITCH_FIXED, PITCH_VARIABLE, PITCH_DONTKNOW
1395 };
1396 ePitch = ePitchA[pF->prgGet()];
1397 // CharSet ...........................................
1398 eCharSet = RTL_TEXTENCODING_MS_1252;
1399 if (aName.EqualsIgnoreCaseAscii("Symbol")
1400 || aName.EqualsIgnoreCaseAscii("Symbol Set")
1401 || aName.EqualsIgnoreCaseAscii("Wingdings")
1402 || aName.EqualsIgnoreCaseAscii("ITC Zapf Dingbats") )
1403 eCharSet = RTL_TEXTENCODING_SYMBOL;
1404 // FontFamily ........................................
1405 USHORT b = pF->ffGet();
1406 static FontFamily eFamilyA[] =
1407 {
1408 FAMILY_DONTKNOW, FAMILY_ROMAN, FAMILY_SWISS, FAMILY_MODERN,
1409 FAMILY_SCRIPT, FAMILY_DECORATIVE
1410 };
1411 if (b < sizeof(eFamilyA))
1412 eFamily = eFamilyA[b];
1413 }
1414 else
1415 {
1416 DBG_ASSERT(FALSE, "WW1Fonts::GetFont: Nicht existenter Font !");
1417 eFamily = FAMILY_SWISS;
1418 aName.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Helv" ));
1419 ePitch = PITCH_VARIABLE;
1420 eCharSet = RTL_TEXTENCODING_MS_1252;
1421 }
1422 }
1423 break;
1424 }
1425 // Extrawurst Hypo
1426 if ( SwFltGetFlag( nFieldFlags, SwFltControlStack::HYPO )
1427 && ( aName.EqualsIgnoreCaseAscii("Helv")
1428 || aName.EqualsIgnoreCaseAscii("Helvetica") ) )
1429 {
1430 aName.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Helvetica Neue" ));
1431 if (eFamily==FAMILY_DONTKNOW)
1432 eFamily = FAMILY_SWISS;
1433 }
1434 else
1435 {
1436 // VCL matcht die Fonts selber
1437 // allerdings passiert bei Helv, Tms Rmn und System Monospaced
1438 // Scheisse, so dass diese ersetzt werden muessen.
1439 // Nach TH sollen diese durch feste Werte ersetzt werden,
1440 // also nicht ueber System::GetStandardFont, damit keine
1441 // Namenslisten auftauchen ( Dieses koennte den User verwirren )
1442 if( aName.EqualsIgnoreCaseAscii("Helv"))
1443 {
1444 aName.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Helvetica" ));
1445 if (eFamily==FAMILY_DONTKNOW)
1446 eFamily = FAMILY_SWISS;
1447 }
1448 else if (aName.EqualsIgnoreCaseAscii("Tms Rmn"))
1449 {
1450 aName.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Times New Roman" ));
1451 if (eFamily==FAMILY_DONTKNOW)
1452 eFamily = FAMILY_ROMAN;
1453 }
1454 else if (aName.EqualsIgnoreCaseAscii("System Monospaced") )
1455 {
1456 aName.AssignAscii( RTL_CONSTASCII_STRINGPARAM( "Courier" ));
1457 ePitch = PITCH_FIXED;
1458 }
1459 }
1460 // nun koennen wir den font basteln: .........................
1461 return SvxFontItem(eFamily, aName, aEmptyStr, ePitch, eCharSet, RES_CHRATR_FONT);
1462 }
1463
1464 /////////////////////////////////////////////////////////////////// Dop
1465 void Ww1Dop::Out(Ww1Shell& rOut)
1466 {
1467 //~ mdt: fehlt
1468 // aDop.fWidowControlGet(); // keine Absatztrennung fuer einzelne Zeilen
1469 long nDefTabSiz = aDop.dxaTabGet();
1470 if (nDefTabSiz < 56)
1471 nDefTabSiz = 709;
1472
1473 // wir wollen genau einen DefaultTab
1474 SvxTabStopItem aNewTab(1, USHORT(nDefTabSiz), SVX_TAB_ADJUST_DEFAULT, RES_PARATR_TABSTOP);
1475 ((SvxTabStop&)aNewTab[0]).GetAdjustment() = SVX_TAB_ADJUST_DEFAULT;
1476 rOut.GetDoc().GetAttrPool().SetPoolDefaultItem( aNewTab); //~ mdt: besser (GetDoc)
1477
1478 SwFrmFmt &rFmt = rOut.GetPageDesc().GetMaster();
1479 W1_DOP& rDOP = GetDOP();
1480 rOut.GetPageDesc().SetLandscape(rDOP.fWideGet());
1481 SwFmtFrmSize aSz(rFmt.GetFrmSize());
1482 aSz.SetWidth(rDOP.xaPageGet());
1483 aSz.SetHeight(rDOP.yaPageGet());
1484 rFmt.SetFmtAttr(aSz);
1485 SvxLRSpaceItem aLR(rDOP.dxaLeftGet()+rDOP.dxaGutterGet(),
1486 rDOP.dxaRightGet(), 0, 0, RES_LR_SPACE);
1487 rFmt.SetFmtAttr(aLR);
1488 SvxULSpaceItem aUL(rDOP.dyaTopGet(), rDOP.dyaBottomGet(), RES_UL_SPACE);
1489 rFmt.SetFmtAttr(aUL);
1490
1491 SwFtnInfo aInfo;
1492 aInfo = rOut.GetDoc().GetFtnInfo(); // Copy-Ctor privat
1493 // wo positioniert ? ( 0 == Section, 1 == Page,
1494 // 2 == beim Text -> Page, 3 == Doc )
1495 switch( rDOP.fpcGet() ){
1496 case 1:
1497 case 2: aInfo.ePos = FTNPOS_PAGE; break;
1498 default: aInfo.ePos = FTNPOS_CHAPTER; break;
1499 }
1500 // aInfo.eNum = ( rDOP.fFtnRestartGet() ) ? FTNNUM_CHAPTER : FTNNUM_DOC;
1501 // Da Sw unter Chapter anscheinend was anderes versteht als PMW
1502 // hier also immer Doc !
1503 aInfo.eNum = FTNNUM_DOC;
1504 // wie neu nummerieren ?
1505 // SW-UI erlaubt Nummer nur bei FTNNUM_DOC
1506 if( rDOP.nFtnGet() > 0 && aInfo.eNum == FTNNUM_DOC )
1507 aInfo.nFtnOffset = rDOP.nFtnGet() - 1;
1508 rOut.GetDoc().SetFtnInfo( aInfo );
1509
1510 }
1511
1512 ///////////////////////////////////////////////////////////////// Assoc
1513 void Ww1Assoc::Out(Ww1Shell& rOut)
1514 {
1515 //~ mdt: fehlen: FileNext, Dot, DataDoc, HeaderDoc, Criteria1,
1516 // Criteria2, Criteria3, Criteria4, Criteria5, Criteria6, Criteria7
1517 SwDocShell *pDocShell(rOut.GetDoc().GetDocShell());
1518 DBG_ASSERT(pDocShell, "no SwDocShell");
1519 if (pDocShell) {
1520 uno::Reference<document::XDocumentPropertiesSupplier> xDPS(
1521 pDocShell->GetModel(), uno::UNO_QUERY_THROW);
1522 uno::Reference<document::XDocumentProperties> xDocProps(
1523 xDPS->getDocumentProperties());
1524 DBG_ASSERT(xDocProps.is(), "DocumentProperties is null");
1525 if (xDocProps.is()) {
1526 xDocProps->setTitle( GetStr(Title) );
1527 xDocProps->setSubject( GetStr(Subject) );
1528 xDocProps->setDescription( GetStr(Comments) );
1529 xDocProps->setKeywords(
1530 ::comphelper::string::convertCommaSeparated( GetStr(KeyWords) ) );
1531 xDocProps->setAuthor( GetStr(Author) );
1532 xDocProps->setModifiedBy( GetStr(LastRevBy) );
1533 }
1534 }
1535 }
1536
1537 //////////////////////////////////////////////////////////// StyleSheet
1538 void Ww1StyleSheet::OutDefaults(Ww1Shell& rOut, Ww1Manager& rMan, USHORT stc)
1539 {
1540 switch (stc){
1541 case 222: // Null
1542 rOut << SvxFontHeightItem(240, 100, RES_CHRATR_FONTSIZE);
1543 rOut << SvxFontItem(rMan.GetFont(2));
1544 break;
1545 case 223: // annotation reference
1546 rOut << SvxFontHeightItem(160, 100, RES_CHRATR_FONTSIZE);
1547 break;
1548 case 224: // annotation text
1549 rOut << SvxFontHeightItem(200, 100, RES_CHRATR_FONTSIZE);
1550 break;
1551 case 225: // table of contents 8
1552 case 226: // table of contents 7
1553 case 227: // table of contents 6
1554 case 228: // table of contents 5
1555 case 229: // table of contents 4
1556 case 230: // table of contents 3
1557 case 231: // table of contents 2
1558 case 232: // table of contents 1
1559 rOut << SvxLRSpaceItem(( 232 - stc ) * 720, 720, 0, 0, RES_LR_SPACE);
1560 // Tabulatoren fehlen noch !
1561 break;
1562 case 233: // index 7
1563 case 234: // und index 6
1564 case 235: // und index 5
1565 case 236: // und index 4
1566 case 237: // und index 3
1567 case 238: // und index 2
1568 rOut << SvxLRSpaceItem(( 239 - stc ) * 360, 0, 0, 0, RES_LR_SPACE);
1569 break;
1570 case 239: // index 1
1571 break;
1572 case 240: // line number
1573 break;
1574 case 241: // index heading
1575 break;
1576 case 242: // footer
1577 case 243:{ // ... und header
1578 SvxTabStopItem aAttr(RES_PARATR_TABSTOP);
1579 SvxTabStop aTabStop;
1580 aTabStop.GetTabPos() = 4535; // 8 cm
1581 aTabStop.GetAdjustment() = SVX_TAB_ADJUST_CENTER;
1582 aAttr.Insert( aTabStop );
1583 aTabStop.GetTabPos() = 9071; // 16 cm
1584 aTabStop.GetAdjustment() = SVX_TAB_ADJUST_RIGHT;
1585 aAttr.Insert( aTabStop );
1586 rOut << aAttr;
1587 }
1588 break;
1589 case 244: // footnote reference
1590 rOut << SvxFontHeightItem(160, 100, RES_CHRATR_FONTSIZE);
1591 rOut << SvxEscapementItem(6 * 100 / 24, 100, RES_CHRATR_ESCAPEMENT);
1592 break;
1593 case 245: // footnote text
1594 rOut << SvxFontHeightItem(200, 100, RES_CHRATR_FONTSIZE);
1595 break;
1596 case 246: // heading 9
1597 case 247: // und heading 8
1598 case 248: // und heading 7
1599 rOut << SvxLRSpaceItem(720, 0, 0, 0, RES_LR_SPACE);
1600 rOut << SvxPostureItem(
1601 rOut.GetPostureItalic()?ITALIC_NONE:ITALIC_NORMAL, RES_CHRATR_POSTURE);
1602 rOut << SvxFontHeightItem(200, 100, RES_CHRATR_FONTSIZE);
1603 break;
1604 case 249: // heading 6
1605 rOut << SvxLRSpaceItem(720, 0, 0, 0, RES_LR_SPACE);
1606 rOut << SvxUnderlineItem(UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE);
1607 rOut << SvxFontHeightItem(200, 100, RES_CHRATR_FONTSIZE);
1608 break;
1609 case 250: // heading 5
1610 rOut << SvxLRSpaceItem(720, 0, 0, 0, RES_LR_SPACE);
1611 rOut << SvxWeightItem(rOut.GetWeightBold()?WEIGHT_NORMAL:WEIGHT_BOLD, RES_CHRATR_WEIGHT);
1612 rOut << SvxFontHeightItem(200, 100, RES_CHRATR_FONTSIZE);
1613 break;
1614 case 251: // heading 4
1615 rOut << SvxLRSpaceItem(360, 0, 0, 0, RES_LR_SPACE);
1616 rOut << SvxUnderlineItem(UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE);
1617 rOut << SvxFontHeightItem(240, 100, RES_CHRATR_FONTSIZE);
1618 break;
1619 case 252: // heading 3
1620 rOut << SvxLRSpaceItem(360, 0, 0, 0, RES_LR_SPACE);
1621 rOut << SvxWeightItem(rOut.GetWeightBold()?WEIGHT_NORMAL:WEIGHT_BOLD, RES_CHRATR_WEIGHT);
1622 rOut << SvxFontHeightItem(240, 100, RES_CHRATR_FONTSIZE);
1623 break;
1624 case 253: // heading 2
1625 rOut << SvxULSpaceItem(120, 0, RES_UL_SPACE);
1626 rOut << SvxWeightItem(rOut.GetWeightBold()?WEIGHT_NORMAL:WEIGHT_BOLD, RES_CHRATR_WEIGHT);
1627 rOut << SvxFontHeightItem(240, 100, RES_CHRATR_FONTSIZE);
1628 rOut << SvxFontItem(rMan.GetFont(2));
1629 break;
1630 case 254: // heading 1
1631 rOut << SvxULSpaceItem(240, 0, RES_UL_SPACE);
1632 rOut << SvxWeightItem(rOut.GetWeightBold()?WEIGHT_NORMAL:WEIGHT_BOLD, RES_CHRATR_WEIGHT);
1633 rOut << SvxUnderlineItem(UNDERLINE_SINGLE, RES_CHRATR_UNDERLINE);
1634 rOut << SvxFontHeightItem(240, 100, RES_CHRATR_FONTSIZE);
1635 rOut << SvxFontItem(rMan.GetFont(2));
1636 break;
1637 case 255: // Normal indent
1638 rOut << SvxLRSpaceItem(720, 0, 0, 0, RES_LR_SPACE);
1639 break;
1640 case 0: // Normal
1641 rOut << SvxFontHeightItem(200, 100, RES_CHRATR_FONTSIZE);
1642 break;
1643 default: // selbstdefiniert
1644 rOut << SvxFontHeightItem(200, 100, RES_CHRATR_FONTSIZE);
1645 break;
1646 }
1647 }
1648
1649 void Ww1StyleSheet::OutOne(Ww1Shell& rOut, Ww1Manager& rMan, USHORT stc)
1650 {
1651 const RES_POOL_COLLFMT_TYPE RES_NONE = RES_POOLCOLL_DOC_END;
1652 RES_POOL_COLLFMT_TYPE aType = RES_NONE;
1653 // aType = RES_POOLCOLL_JAKETADRESS; break;
1654 // aType = RES_POOLCOLL_LISTS_BEGIN; break;
1655 // aType = RES_POOLCOLL_SENDADRESS; break;
1656 // aType = RES_POOLCOLL_SIGNATURE; break;
1657 // aType = RES_POOLCOLL_TEXT_NEGIDENT; break;
1658 // aType = RES_POOLCOLL_TOX_IDXH; break;
1659 switch (stc)
1660 {
1661 case 222: // Null
1662 aType = RES_POOLCOLL_TEXT; break; //???
1663 case 223: // annotation reference
1664 break;
1665 case 224: // annotation text
1666 break;
1667 case 225: // table of contents 8
1668 aType = RES_POOLCOLL_TOX_CNTNT8; break;
1669 case 226: // table of contents 7
1670 aType = RES_POOLCOLL_TOX_CNTNT7; break;
1671 case 227: // table of contents 6
1672 aType = RES_POOLCOLL_TOX_CNTNT6; break;
1673 case 228: // table of contents 5
1674 aType = RES_POOLCOLL_TOX_CNTNT5; break;
1675 case 229: // table of contents 4
1676 aType = RES_POOLCOLL_TOX_CNTNT4; break;
1677 case 230: // table of contents 3
1678 aType = RES_POOLCOLL_TOX_CNTNT3; break;
1679 case 231: // table of contents 2
1680 aType = RES_POOLCOLL_TOX_CNTNT2; break;
1681 case 232: // table of contents 1
1682 aType = RES_POOLCOLL_TOX_CNTNT1; break;
1683 case 233: // index 7
1684 break;
1685 case 234: // index 6
1686 break;
1687 case 235: // index 5
1688 break;
1689 case 236: // index 4
1690 break;
1691 case 237: // index 3
1692 aType = RES_POOLCOLL_TOX_IDX3; break;
1693 case 238: // index 2
1694 aType = RES_POOLCOLL_TOX_IDX2; break;
1695 case 239: // index 1
1696 aType = RES_POOLCOLL_TOX_IDX1; break;
1697 case 240: // line number
1698 break;
1699 case 241: // index heading
1700 break;
1701 case 242: // footer
1702 aType = RES_POOLCOLL_FOOTER; break;
1703 case 243: // header
1704 aType = RES_POOLCOLL_HEADER; break;
1705 case 244: // footnote reference
1706 break;
1707 case 245: // footnote text
1708 aType = RES_POOLCOLL_FOOTNOTE; break;
1709 case 246: // heading 9
1710 break;
1711 case 247: // heading 8
1712 break;
1713 case 248: // heading 7
1714 break;
1715 case 249: // heading 6
1716 break;
1717 case 250: // heading 5
1718 aType = RES_POOLCOLL_HEADLINE5; break;
1719 case 251: // heading 4
1720 aType = RES_POOLCOLL_HEADLINE4; break;
1721 case 252: // heading 3
1722 aType = RES_POOLCOLL_HEADLINE3; break;
1723 case 253: // heading 2
1724 aType = RES_POOLCOLL_HEADLINE2; break;
1725 case 254: // heading 1
1726 aType = RES_POOLCOLL_HEADLINE1; break;
1727 case 255: // Normal indent
1728 aType = RES_POOLCOLL_TEXT_IDENT; break;
1729 case 0: // Normal
1730 aType = RES_POOLCOLL_STANDARD; break;
1731 // aType = RES_POOLCOLL_TEXT; break; // Das ist "textkoerper"
1732 }
1733 if (aType == RES_NONE)
1734 rOut.BeginStyle(stc, GetStyle(stc).GetName() );
1735 else
1736 rOut.BeginStyle(stc, aType);
1737 OutDefaults(rOut, rMan, stc);
1738 GetStyle(stc).Out(rOut, rMan);
1739 rOut.EndStyle();
1740 // rMan.SetInApo(FALSE);
1741 }
1742 // OutOneWithBase() liest einen Style mit OutOne() einen Style ein
1743 // Jedoch liest er, wenn noch nicht geschehen, den Basisstyle rekursiv ein
1744 void Ww1StyleSheet::OutOneWithBase(Ww1Shell& rOut, Ww1Manager& rMan,
1745 USHORT stc, BYTE* pbStopRecur )
1746 {
1747 // SH: lineares Einlesen ist Scheisse, da dann BasedOn nicht gesetzt
1748 // werden kann und ausserdem Toggle- und Modify-Attrs (z.B. Tabs ) nicht gehen.
1749
1750 Ww1Style& rSty = GetStyle(stc);
1751 USHORT nBase = rSty.GetnBase();
1752 if( nBase != stc
1753 && !rOut.IsStyleImported( nBase )
1754 && GetStyle(nBase).IsUsed()
1755 && !pbStopRecur[nBase] ){
1756
1757 pbStopRecur[nBase] = 1;
1758 OutOneWithBase( rOut, rMan, nBase, pbStopRecur ); // Rekursiv
1759 }
1760 OutOne( rOut, rMan, stc );
1761 }
1762
1763 void Ww1StyleSheet::Out(Ww1Shell& rOut, Ww1Manager& rMan)
1764 {
1765 USHORT stc;
1766 BYTE bStopRecur[256];
1767 memset( bStopRecur, FALSE, sizeof(bStopRecur) );
1768
1769 // 1. Durchlauf: Styles mit Basisstyles rekursiv
1770 for (stc=0;stc<Count();stc++)
1771 if (GetStyle(stc).IsUsed() && !rOut.IsStyleImported( stc ) )
1772 OutOneWithBase( rOut, rMan, stc, bStopRecur );
1773
1774 // 2. Durchlauf: Follow-Styles
1775 for (stc=0;stc<Count();stc++){
1776 Ww1Style& rSty = GetStyle(stc);
1777 if ( rSty.IsUsed() ){
1778 USHORT nNext = rSty.GetnNext();
1779 if( nNext != stc && GetStyle(nNext).IsUsed() )
1780 rOut.NextStyle( stc, nNext );
1781 }
1782 }
1783 }
1784
1785 ////////////////////////////////////////////////////////////// Picture
1786 static ULONG GuessPicSize(W1_PIC* pPic)
1787 {
1788 USHORT maxx = pPic->mfp.xExtGet();
1789 USHORT padx = ((maxx + 7) / 8) * 8;
1790 USHORT maxy = pPic->mfp.yExtGet();
1791 return 120L + (ULONG)padx * maxy;
1792 }
1793
1794 //
1795 // folgende methode schreibt eine windows-.BMP-datei aus einem
1796 // embeddeten bild in ww-1 dateien
1797 // gelesen wird 4-bit format, geschrieben jedoch 8-bit.
1798 //
1799 void Ww1Picture::WriteBmp(SvStream& rOut)
1800 {
1801 long nSize = pPic->lcbGet() - (sizeof(*pPic)-sizeof(pPic->rgb));
1802 BYTE* p = pPic->rgbGet();
1803 USHORT maxx = pPic->mfp.xExtGet();
1804 USHORT padx = ((maxx + 7) / 8) * 8;
1805 USHORT maxy = pPic->mfp.yExtGet();
1806
1807 /*USHORT unknown1 = SVBT16ToShort(p);*/ p+= sizeof(SVBT16); nSize -= sizeof(SVBT16);
1808 /*USHORT unknown2 = SVBT16ToShort(p);*/ p+= sizeof(SVBT16); nSize -= sizeof(SVBT16);
1809 #if OSL_DEBUG_LEVEL > 1
1810 USHORT x = SVBT16ToShort(p);
1811 (void) x;
1812 #endif
1813 p+= sizeof(SVBT16); nSize -= sizeof(SVBT16);
1814 #if OSL_DEBUG_LEVEL > 1
1815 USHORT y = SVBT16ToShort(p);
1816 (void) y;
1817 #endif
1818 p+= sizeof(SVBT16); nSize -= sizeof(SVBT16);
1819 #if OSL_DEBUG_LEVEL > 1
1820 USHORT planes = SVBT16ToShort(p);
1821 (void) planes;
1822 #endif
1823 p+= sizeof(SVBT16); nSize -= sizeof(SVBT16);
1824 #if OSL_DEBUG_LEVEL > 1
1825 USHORT bitcount = SVBT16ToShort(p);
1826 (void) bitcount;
1827 #endif
1828 p+= sizeof(SVBT16); nSize -= sizeof(SVBT16);
1829
1830 #if OSL_DEBUG_LEVEL > 1
1831 DBG_ASSERT(x==maxx, "Ww1Picture");
1832 DBG_ASSERT(y==maxy, "Ww1Picture");
1833 DBG_ASSERT(planes==1, "Ww1Picture");
1834 DBG_ASSERT(bitcount==4, "Ww1Picture");
1835 #endif
1836
1837 DBG_ASSERT(16*3+padx*maxy/2==nSize, "Ww1Picture");
1838
1839 SVBT32 tmpLong;
1840 SVBT16 tmpShort;
1841 SVBT8 tmpByte;
1842 #define wLong(n) \
1843 UInt32ToSVBT32(n, tmpLong); \
1844 if ((rOut.Write(tmpLong, sizeof(SVBT32))) != sizeof(SVBT32)) goto error;
1845 #define wShort(n) \
1846 ShortToSVBT16(n, tmpShort); \
1847 if ((rOut.Write(tmpShort, sizeof(SVBT16))) != sizeof(SVBT16)) goto error;
1848 #define wByte(n) \
1849 ByteToSVBT8(n, tmpByte); \
1850 if ((rOut.Write(tmpByte, sizeof(SVBT8))) != sizeof(SVBT8)) goto error;
1851 wByte('B'); wByte('M');
1852 wLong(54 + 4 * 16 + padx * maxy);
1853 wLong(0);
1854 wLong(54 + 4 * 16);
1855 wLong(40);
1856 wLong(maxx);
1857 wLong(maxy);
1858 wShort(1);
1859 wShort(8);
1860 wLong(0);
1861 wLong(0);
1862 wLong(0);
1863 wLong(0);
1864 wLong(16);
1865 wLong(16);
1866 USHORT i;
1867 for (i=0;nSize>0&&i<16;i++)
1868 {
1869 wByte(*p);
1870 p++;
1871 nSize -= sizeof(BYTE);
1872 wByte(*p);
1873 p++;
1874 nSize -= sizeof(BYTE);
1875 wByte(*p);
1876 p++;
1877 nSize -= sizeof(BYTE);
1878 wByte(0);
1879 }
1880 DBG_ASSERT(padx*maxy/2==nSize, "Ww1Picture");
1881 USHORT j;
1882 #if 1
1883 {
1884 BYTE* pBuf = new BYTE[padx];
1885 for (j=0;nSize>0&&j<maxy;j++)
1886 {
1887 BYTE* q = pBuf;
1888 for (i=0;nSize>0&&i<maxx;i+=2)
1889 {
1890 *q++ = *p>>4;
1891 *q++ = *p&0xf;
1892 p++;
1893 nSize -= sizeof(BYTE);
1894 }
1895 for (;i<padx;i+=2)
1896 {
1897 *q++ = 0;
1898 p++;
1899 nSize -= sizeof(BYTE);
1900 }
1901 if(rOut.Write(pBuf, padx) != padx){
1902 delete pBuf;
1903 goto error;
1904 }
1905 }
1906 delete pBuf;
1907 }
1908 #else
1909 for (j=0;nSize>0&&j<maxy;j++)
1910 {
1911 for (i=0;nSize>0&&i<maxx;i+=2)
1912 {
1913 wByte(*p>>4);
1914 wByte(*p&0xf);
1915 p++;
1916 nSize -= sizeof(BYTE);
1917 }
1918 for (;i<padx;i+=2)
1919 {
1920 wByte(0);
1921 p++;
1922 nSize -= sizeof(BYTE);
1923 }
1924 }
1925 #endif
1926 DBG_ASSERT(nSize==0, "Ww1Picture");
1927 #undef wLong
1928 #undef wShort
1929 #undef wByte
1930 rOut.Seek(0);
1931 return;
1932 error:
1933 ;
1934 }
1935
1936 void Ww1Picture::Out(Ww1Shell& rOut, Ww1Manager& /*rMan*/)
1937 {
1938 Graphic* pGraphic = 0;
1939 USHORT mm;
1940 switch (mm = pPic->mfp.mmGet())
1941 {
1942 case 8: // embedded metafile
1943 {
1944 SvMemoryStream aOut(8192, 8192);
1945 aOut.Write(pPic->rgbGet(), pPic->lcbGet() -
1946 (sizeof(*pPic)-sizeof(pPic->rgb)));
1947 aOut.Seek(0);
1948 GDIMetaFile aWMF;
1949 if (ReadWindowMetafile( aOut, aWMF, NULL ) && aWMF.GetActionCount() > 0)
1950 {
1951 aWMF.SetPrefMapMode(MapMode(MAP_100TH_MM));
1952 Size aOldSiz(aWMF.GetPrefSize());
1953 Size aNewSiz(pPic->mfp.xExtGet(), pPic->mfp.yExtGet());
1954 Fraction aFracX(aNewSiz.Width(), aOldSiz.Width());
1955 Fraction aFracY(aNewSiz.Height(), aOldSiz.Height());
1956 aWMF.Scale(aFracX, aFracY);
1957 aWMF.SetPrefSize(aNewSiz);
1958 pGraphic = new Graphic(aWMF);
1959 }
1960 break;
1961 }
1962 case 94: // embedded name SH:??? Was denn nun ? Embeddet oder Name ?
1963 case 98: // TIFF-Name
1964 {
1965 String aDir( (sal_Char*)pPic->rgbGet(),
1966 (USHORT)(pPic->lcbGet() - (sizeof(*pPic)-sizeof(pPic->rgb))),
1967 RTL_TEXTENCODING_MS_1252 );
1968 //SvFileStream aOut(aDir, STREAM_READ|STREAM_WRITE|STREAM_TRUNC);
1969 rOut.AddGraphic( aDir );
1970 }
1971 break;
1972 case 97: // embedded bitmap
1973 // case 99: // SH: bei meinem BspDoc 41738.doc auch embedded Bitmap,
1974 // aber leider anderes Format
1975 {
1976 ULONG nSiz = GuessPicSize(pPic);
1977 SvMemoryStream aOut(nSiz, 8192);
1978 WriteBmp(aOut);
1979 Bitmap aBmp;
1980 aOut >> aBmp;
1981 pGraphic = new Graphic(aBmp);
1982 }
1983 default:
1984 DBG_ASSERT(pPic->mfp.mmGet() == 97, "Ww1Picture");
1985 }
1986 if (pGraphic)
1987 rOut << *pGraphic;
1988 }
1989
1990 ////////////////////////////////////////////////////////// HeaderFooter
1991 void Ww1HeaderFooter::Start(Ww1Shell& rOut, Ww1Manager& rMan)
1992 {
1993 // wird sowieso nur bei SEPs aufgerufen, keine weitere pruefung
1994 // noetig:
1995 if (!rMan.Pushed())
1996 {
1997 while ((*this)++)
1998 switch (eHeaderFooterMode)
1999 {
2000 case FtnSep:
2001 break;
2002 case FtnFollowSep:
2003 break;
2004 case FtnNote:
2005 break;
2006 case EvenHeadL:
2007 break;
2008 case OddHeadL:
2009 {
2010 ULONG begin = 0;
2011 ULONG end = 0;
2012 if (FillOddHeadL(begin, end))
2013 {
2014 Ww1HddText* pText = new Ww1HddText(rMan.GetFib());
2015 pText->Seek(begin);
2016 pText->SetCount(end-begin);
2017 rOut.BeginHeader();
2018 rMan.Push1(pText, pText->Offset(rMan.GetFib()), begin,
2019 new Ww1HeaderFooterFields(rMan.GetFib()));
2020 rOut << rMan;
2021 rMan.Pop();
2022 rOut.EndHeaderFooter();
2023 return;
2024 }
2025 }
2026 break;
2027 case EvenFootL:
2028 break;
2029 case OddFootL:
2030 {
2031 ULONG begin = 0;
2032 ULONG end = 0;
2033 if (FillOddFootL(begin, end))
2034 {
2035 Ww1HddText* pText = new Ww1HddText(rMan.GetFib());
2036 pText->Seek(begin);
2037 pText->SetCount(end-begin);
2038 rOut.BeginFooter();
2039 rMan.Push1(pText, pText->Offset(rMan.GetFib()), begin,
2040 new Ww1HeaderFooterFields(rMan.GetFib()));
2041 rOut << rMan;
2042 rMan.Pop();
2043 rOut.EndHeaderFooter();
2044 return;
2045 }
2046 }
2047 break;
2048 case FirstHeadL:
2049 break;
2050 default:
2051 break;
2052 }
2053 }
2054 }
2055
2056 void Ww1HeaderFooter::Stop(Ww1Shell& rOut, Ww1Manager& rMan, sal_Unicode&)
2057 {
2058 if (!rMan.Pushed() && eHeaderFooterMode != None
2059 // && rMan.GetText().Where() >= rMan.GetText().Count()
2060 )
2061 {
2062 Start(rOut, rMan);
2063 }
2064 }
2065
2066
vba interoperability for OOo