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