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