1 /**************************************************************
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing,
14 * software distributed under the License is distributed on an
15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16 * KIND, either express or implied. See the License for the
17 * specific language governing permissions and limitations
18 * under the License.
19 *
20 *************************************************************/
21
22
23
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_svtools.hxx"
26
27 #include <rtl/math.h>
28 #include <tools/config.hxx>
29 #include <svtools/filter.hxx>
30 #include "sgffilt.hxx"
31 #include "sgfbram.hxx"
32 #include "sgvmain.hxx"
33 // #include "Debug.c"
34
35 extern SgfFontLst* pSgfFonts;
36
37 #ifndef abs
38 #define abs(x) ((x)<0 ? -(x) : (x))
39 #endif
40
41
42 ////////////////////////////////////////////////////////////////////////////////////////////////////
43 //
44 // Einschraenkungen: Schatten nur grau, 2D und mit fixem Abstand.
45 //
46 //
47 //
48 //
49 ////////////////////////////////////////////////////////////////////////////////////////////////////
50
51 /////////////////////////////////////////////////////////////////////////////////
52 /////////////////////////////////////////////////////////////////////////////////
53 /////////////////////////////////////////////////////////////////////////////////
54 // AbsBase.Pas
55
56 // die folgenden Werte sind in % vom maximalen Schriftgrad der Zeile */
57 #define UndlSpace 5 /* Untersteichungsabstand von der Baseline */
58 #define UndlWidth 6 /* Untersteichungsdicke */
59 #define UndlSpac2 7 /* Zwischenraum bei doppelter Unterstreichung */
60 #define StrkSpace 25 /* Abstand der Durchstreichlinie von der Baseline*/
61 #define StrkWidth 5 /* Durchstreichungsliniendicke */
62 #define StrkSpac2 7 /* Zwischenraum bei doppelter Durchstreichung */
63 #define OutlWidth 2 /* Strichstaerke ist 2% vom Schriftgrad */
64
65 // vvv Sonderzeichen im TextBuffer vvv
66 #define TextEnd 0 /* ^@ Ende der Zeichenkette */
67 #define HardSpace 6 /* ^F Hartspace (wird nicht umbrochen) ,' ' */
68 #define GrafText 7 /* ^G Im Text eingebundene Grafik (future) */
69 #define Tabulator 9 /* ^I Tabulatorzeichen, Pfeil */
70 #define LineFeed 10 /* ^J Neue Zeile */
71 #define SoftTrennK 11 /* ^K Zeichen fuer k-c-Austausch bei Trennung, 'k' */
72 #define AbsatzEnd 13 /* ^M Neuer Absatz =CR */
73 #define HardTrenn 16 /* ^P Hartes Trennzeichen (wird nicht umbrochen), '-' */
74 #define SoftTrennAdd 19 /* ^S Zusatz-Zeichen Trennung von z.b."Schiff-fahrt" */
75 #define Paragraf 21 /* ^U Zeichen welches fuer Paragraf-Zeichen */
76 #define Escape 27 /* ^[ Escapesequenz einleiten */
77 #define SoftTrenn 31 /* ^_ Weiches Trennzeichen, '-' nur Zeilenende */
78 #define MaxEscValLen 8
79 #define MaxEscLen (MaxEscValLen+3)
80
81 //==============================================================================
82 // Escapesequenzen: [Esc]<Ident><Value>[Esc] also mind. 4 Char
83 // Max. Laenge von Value soll sein: 8 Char (7+Vorzeichen). Demnach max. Laenge
84 // einer Escapesequenz: 11 Char.
85 // Identifer:
86
87 #define EscFont 'F' /* FontID, z.B. 92500 fuer CG Times */
88 #define EscGrad 'G' /* Schriftgrad 1..255 fuer <<Pt-127<<Pt */
89 #define EscBreit 'B' /* Breite 1..255% des Schriftgrades */
90 #define EscKaptS 'K' /* Kapitaelchengroesse 1..255% des Schriftgrades */
91 #define EscLFeed 'L' /* Zeilenabstand 1..32767% vom max. Schriftgrad der Zeile */
92 // oder 1..32767 fuer 1..16383<<Pt absolut (Wenn Bit 15=1)
93 #define EscSlant 'S' /* Kursiv(Winkel) 1..8999 fuer 0.01deg..89.99deg */
94 #define EscVPos 'V' /* Zeichen Vertikal-Position 1..255 fuer <<Pt..127<<Pt */
95 #define EscZAbst 'Z' /* Zeichenabstand -128..127% */
96 #define EscHJust 'A' /* H-Justify Absatz: Links, Zentr, Rechts, Block, Austreibend, Gesperrt (0..5)*/
97
98 #define EscFarbe 'C' /* Farbe 0..7 */
99 #define EscBFarb 'U' /* BackFarbe 0..7 */
100 #define EscInts 'I' /* Farbintensitaet 0..100% */
101 #define EscMustr 'M' /* Muster 0..? inkl. Transp... */
102 #define EscMFarb 'O' /* Musterfarbe 0..7 */
103 #define EscMBFrb 'P' /* 2. Musterfarbe 0..7 */
104 #define EscMInts 'W' /* Musterintensitaet 0..7 */
105
106 #define EscSMstr 'E' /* Schattenmuster 0..? inkl. Transp... */
107 #define EscSFarb 'R' /* Schattenfarbe 0..7 */
108 #define EscSBFrb 'T' /* 2. Schattenfarbe 0..7 */
109 #define EscSInts 'Q' /* Schattenintensitaet 0..7 */
110
111 #define EscSXDst 'X' /* Schattenversatz X 0..100% */
112 #define EscSYDst 'Y' /* Schattenversatz Y 0..100% */
113 #define EscSDist 'D' /* Schattenversatz X-Y 0..100% */
114
115 #define EscBold 'f' /* Fett */
116 #define EscLSlnt 'l' /* LKursiv */
117 #define EscRSlnt 'r' /* RKursiv */
118 #define EscUndln 'u' /* Unterstrichen */
119 #define EscDbUnd 'p' /* doppelt Unterstrichen */
120 #define EscKaptF 'k' /* Kapitaelchenflag */
121 #define EscStrik 'd' /* Durchgestrichen */
122 #define EscDbStk 'e' /* doppelt Durchgestrichen */
123 #define EscSupSc 'h' /* Hochgestellt */
124 #define EscSubSc 't' /* Tiefgestellt */
125 #define Esc2DShd 's' /* 2D-Schatten */
126 #define Esc3DShd 'j' /* 3D-Schatten */
127 #define Esc4DShd 'i' /* 4D-Schatten */
128 #define EscEbShd 'b' /* Embossed */
129
130 // AllEscIdent =[EscFont, EscGrad, EscBreit,EscKaptS,EscLFeed,EscSlant,EscVPos, EscZAbst,EscHJust,
131 // EscFarbe,EscBFarb,EscInts, EscMustr,EscMFarb,EscMBFrb,EscMInts,
132 // EscSMstr,EscSFarb,EscSBFrb,EscSInts,EscSXDst,EscSYDst,EscSDist,
133 // EscBold, EscLSlnt,EscRSlnt,EscUndln,EscDbUnd,EscKaptF,EscStrik,EscDbStk,
134 // EscSupSc,EscSubSc,Esc2DShd,Esc3DShd,Esc4DShd];
135 // Justify muss spaetestens am Anfang des Absatzes stehen
136 #define EscSet ' ' /* Flag setzen */
137 #define EscReset ' ' /* Flag loeschen */
138 #define EscDeflt '\x11' /* Flag auf default setzen */
139 #define EscToggl ' ' /* Flag Toggeln */
140 #define EscRelat '%'
141 #define EscNoFlg 0
142 #define EscNoVal -2147483647 /* -MaxLongInt */
143 //==============================================================================
144 #define NoTrenn 0xFFFF /* Wert fuer Parameter 'Rest' von GetTextChar(), wenn auf keinen Fall getrennt werden soll */
145 #define DoTrenn 0xFFFE /* Wert fuer Parameter 'Rest' von GetTextChar(), wenn getrennt werden soll */
146
147 #define MaxLineChars 1024
148
149 #define ChrXPosArrSize (MaxLineChars+1+1) /* 2k - Beginnt mit 0 im gegensatz zu StarDraw */
150 #define CharLineSize (MaxLineChars+1+1)
151 #define EscStr (UCHAR[MaxEscLen+1]);
152
153 #define MinChar 32
154 #define MaxChar 255
155
156
157 //==============================================================================
158
159 #define DefaultCharWidth 4800
160 #define GradDiv 2
161 #define CharTopToBase 100 /* wegen Apostrophe und Umlaute mehr als 75% */
162 #define CharTopToBtm 120 /* Zeilenhoehe ist groesser als Schriftgrad */
163 // bei Avanti-Bold 'ue' eigentlich sogar 130%
164
165 // end of AbsBase.Pas
166 /////////////////////////////////////////////////////////////////////////////////
167 /////////////////////////////////////////////////////////////////////////////////
168 /////////////////////////////////////////////////////////////////////////////////
169
170
171
172 /////////////////////////////////////////////////////////////////////////////////
173 /////////////////////////////////////////////////////////////////////////////////
174 /////////////////////////////////////////////////////////////////////////////////
175 // DefBase.Pas
176
177 #define TextBoldBit 0x0001 /* Fett */
178 #define TextRSlnBit 0x0002 /* Kursiv */
179 #define TextUndlBit 0x0004 /* Unterstrichen */
180 #define TextStrkBit 0x0008 /* Durchgesteichen */
181 #define TextSupSBit 0x0010 /* Hocgestellt */
182 #define TextSubSBit 0x0020 /* Tiefgestellt */
183 #define TextKaptBit 0x0040 /* Kapitaelchen */
184 #define TextLSlnBit 0x0080 /* Linkskursiv */
185 #define TextDbUnBit 0x0100 /* Doppelt unterstrichen */
186 #define TextDbStBit 0x0200 /* Doppelt durchgestrichen */
187 #define TextSh2DBit 0x0400 /* 2D-Schatten 2.0 */
188 #define TextSh3DBit 0x0800 /* 3D-Schatten 2.0 */
189 #define TextSh4DBit 0x1000 /* 4D-Schatten 2.0 */
190 #define TextShEbBit 0x2000 /* Embossed-Schatten 2.0 */
191 #define FontAtrBits (TextBoldBit | TextRSlnBit)
192
193 #define THJustLeft 0x00
194 #define THJustCenter 0x01
195 #define THJustRight 0x02
196 #define THJustBlock 0x03
197 #define THJustDrvOut 0x04 /* Austreibend Formatiert */
198 #define THJustLocked 0x05 /* A l s S p e r r s c h r i f t */
199 #define TVJustTop 0x00 /* Future */
200 #define TVJustCenter 0x10 /* Future */
201 #define TVJustBottom 0x20 /* Future */
202 #define TVJustBlock 0x30 /* Future */
203
204 #define MaxCharSlant 4200 /* Maximal 42deg kursiv ! */
205
206 // end of DefBase.Pas
207 /////////////////////////////////////////////////////////////////////////////////
208 /////////////////////////////////////////////////////////////////////////////////
209 /////////////////////////////////////////////////////////////////////////////////
210
211
212 sal_Bool CheckTextOutl(ObjAreaType& F, ObjLineType& L);
213
CheckTextOutl(ObjAreaType & F,ObjLineType & L)214 sal_Bool CheckTextOutl(ObjAreaType& F, ObjLineType& L)
215 {
216 return (F.FIntens!=L.LIntens) ||
217 ((F.FFarbe!=L.LFarbe) && (F.FIntens>0)) ||
218 ((F.FBFarbe!=L.LBFarbe) && (F.FIntens<100));
219 }
220
221
222 /////////////////////////////////////////////////////////////////////////////////
223 /////////////////////////////////////////////////////////////////////////////////
224 /////////////////////////////////////////////////////////////////////////////////
225 // Misc.Pas
226
hPoint2Sgf(short a)227 short hPoint2Sgf(short a)
228 {
229 long b;
230 b=long(a)*127*SgfDpmm/(144*5);
231 return short(b);
232 }
233
Sgf2hPoint(short a)234 short Sgf2hPoint(short a)
235 {
236 long b;
237 b=long(a)*5*144/(127*SgfDpmm);
238 return short(b);
239 }
240
241 // End of Misc.Pas
242 /////////////////////////////////////////////////////////////////////////////////
243 /////////////////////////////////////////////////////////////////////////////////
244 /////////////////////////////////////////////////////////////////////////////////
245
246
247
248 /////////////////////////////////////////////////////////////////////////////////
249 /////////////////////////////////////////////////////////////////////////////////
250 /////////////////////////////////////////////////////////////////////////////////
251 // AbsRead.Pas
252
253 // ======================================================================
254 // Function GetTopToBaseLine() Function GetBaseLineToBtm()
255 //
256 // Abstand von Zeilenoberkante bis BaseLine bzw. von BaseLine bis
257 // Unterkante berechnen. Alles in SGF-Units.
258 // ======================================================================
259
GetTopToBaseLine(sal_uInt16 MaxGrad)260 sal_uInt16 GetTopToBaseLine(sal_uInt16 MaxGrad)
261 {
262 long ret;
263 ret=long(MaxGrad)*long(CharTopToBase) /long(100);
264 return sal_uInt16(ret);
265 }
266
267 // ======================================================================
268 // Function GetTextChar() Function GetTextCharConv()
269 //
270 // Liest ein Zeichen aus dem Textbuffer, wertet dabei eventuell
271 // auftretende Escapesequenzen aus und setzt dementsprechend den
272 // Ein-/Ausgabeparameter AktAtr. Index wird entsprechend erhoeht.
273 // Der Parameter Rest muss immer die Anzahl der Zeichen beinhalten,
274 // den angeforderten Zeichen in der aktuellen Zeile noch folgen.
275 // Ansonsten funktioniert die Silbentrennung nicht richtig. Gibt man
276 // stattdessen die Konstante NoTrenn an, wird in keinem Fall
277 // getrennt, die Konstante DoTrenn bewirkt dagegen, dass ueberall dort
278 // getrennt wird, wo ein SoftTrenner vorkommt.
279 //
280 // SoftTrenner werden immer in ein Minuszeichen konvertiert.
281 // GetTextCharConv() konvertiert zusaetzlich HardSpace und AbsatzEnde
282 // in Spaces sowie HardTrenner in Minuszeichen. TextEnde wird immer
283 // als Char(0) geliefert.
284 // ======================================================================
285
286
287
ConvertTextChar(UCHAR c)288 UCHAR ConvertTextChar(UCHAR c)
289 {
290 if (c<32) {
291 switch (c) {
292 case HardSpace : c=' '; break;
293 case AbsatzEnd : c=' '; break;
294 case SoftTrenn : c='-'; break;
295 case HardTrenn : c='-'; break;
296 case SoftTrennK : c='-'; break;
297 case SoftTrennAdd: c='-';
298 }
299 }
300 return c;
301 }
302
303
304
GetSchnittBit(UCHAR c)305 sal_uInt16 GetSchnittBit(UCHAR c)
306 {
307 sal_uInt16 r=0;
308 switch (c) {
309 case EscBold : r=TextBoldBit; break;
310 case EscRSlnt: r=TextRSlnBit; break;
311 case EscUndln: r=TextUndlBit; break;
312 case EscStrik: r=TextStrkBit; break;
313 case EscDbUnd: r=TextDbUnBit; break;
314 case EscDbStk: r=TextDbStBit; break;
315 case EscSupSc: r=TextSupSBit; break;
316 case EscSubSc: r=TextSubSBit; break;
317 case EscKaptF: r=TextKaptBit; break;
318 case EscLSlnt: r=TextLSlnBit; break;
319 case Esc2DShd: r=TextSh2DBit; break;
320 case Esc3DShd: r=TextSh3DBit; break;
321 case Esc4DShd: r=TextSh4DBit; break;
322 case EscEbShd: r=TextShEbBit;
323 }
324 return r;
325 }
326
327
328
ChgValue(long Def,long Min,long Max,UCHAR FlgVal,long NumVal)329 long ChgValue(long Def, long Min, long Max, UCHAR FlgVal, long NumVal)
330 {
331 long r=0;
332
333 if (FlgVal==EscDeflt) {
334 r=Def; // zurueck auf Default
335 } else {
336 if (NumVal!=EscNoVal) r=NumVal; // Hart setzen
337 }
338
339 if (Min!=0 || Max!=0) {
340 if (r>Max) r=Max;
341 if (r<Min) r=Min;
342 }
343 return r;
344 }
345
346
347
ChgSchnittBit(sal_uInt16 Bit,sal_uInt16 Radio1,sal_uInt16 Radio2,sal_uInt16 Radio3,UCHAR FlgVal,sal_uInt16 Schnitt0,sal_uInt16 & Schnitt)348 void ChgSchnittBit(sal_uInt16 Bit, sal_uInt16 Radio1, sal_uInt16 Radio2, sal_uInt16 Radio3,
349 UCHAR FlgVal, sal_uInt16 Schnitt0, sal_uInt16& Schnitt)
350 {
351 sal_uInt16 All,Rad;
352
353 Rad=Radio1 | Radio2 | Radio3;
354 All=Bit | Rad;
355
356 switch (FlgVal) {
357 case EscSet : Schnitt=(Schnitt & ~All) | Bit; break;
358 case EscReset: Schnitt=(Schnitt & ~All); break;
359 case EscDeflt: Schnitt=(Schnitt & ~All) | (Schnitt0 & All); break;
360 case EscToggl: Schnitt=(Schnitt & ~Rad) ^ Bit;
361 }
362 }
363
364
365
GetNextChar(UCHAR * TBuf,sal_uInt16 Index)366 UCHAR GetNextChar(UCHAR* TBuf, sal_uInt16 Index)
367 {
368 sal_uInt16 Cnt;
369 while (TBuf[Index]==Escape) {
370 Index++;
371 Cnt=0;
372 while (TBuf[Index]!=Escape && Cnt<=MaxEscLen) {
373 Index++; Cnt++; }
374 Index++;
375 }
376 return TBuf[Index];
377 }
378
379
380
ProcessOne(UCHAR * TBuf,sal_uInt16 & Index,ObjTextType & Atr0,ObjTextType & AktAtr,sal_Bool ScanEsc)381 UCHAR ProcessOne(UCHAR* TBuf, sal_uInt16& Index,
382 ObjTextType& Atr0, ObjTextType& AktAtr,
383 sal_Bool ScanEsc)
384 {
385 UCHAR c;
386 UCHAR Ident;
387 sal_Bool Ende;
388 sal_Bool q;
389 UCHAR FlgVal;
390 long NumVal;
391 long Sgn;
392 short i;
393 sal_Bool EoVal;
394
395 do {
396 c=TBuf[Index]; Index++;
397 Ende=(c!=Escape);
398 if (Ende==sal_False) {
399 c=TBuf[Index]; Index++;
400 Ident=c; // Identifer merken
401 FlgVal=EscNoFlg;
402 NumVal=EscNoVal;
403 c=TBuf[Index]; Index++; // Hier faengt der Wert an
404 if (c==EscSet || c==EscReset || c==EscDeflt || c==EscToggl) FlgVal=c; else {
405 if (c=='-') Sgn=-1; else Sgn=1;
406 if (c=='+' || c=='-') { c=TBuf[Index]; Index++; }
407 i=MaxEscValLen;
408 NumVal=0;
409 do {
410 NumVal=10*NumVal+c-'0';
411 EoVal=(TBuf[Index]<'0' || TBuf[Index]>'9');
412 if (EoVal==sal_False) { c=TBuf[Index]; Index++; }
413 i--;
414 } while (i>0 && EoVal==sal_False);
415 NumVal=Sgn*NumVal;
416 }
417 q=!CheckTextOutl(AktAtr.F,AktAtr.L);
418
419 switch (Ident) {
420 case EscFont : AktAtr.SetFont(sal_uLong (ChgValue(Atr0.GetFont(),0,0 ,FlgVal,NumVal)));break;
421 case EscGrad : AktAtr.Grad =sal_uInt16(ChgValue(Atr0.Grad, 2,2000 ,FlgVal,NumVal)); break;
422 case EscBreit: AktAtr.Breite =sal_uInt16(ChgValue(Atr0.Breite, 1,1000 ,FlgVal,NumVal)); break;
423 case EscKaptS: AktAtr.Kapit =(sal_uInt8)(ChgValue(Atr0.Kapit, 1,255 ,FlgVal,NumVal)); break;
424 case EscLFeed: AktAtr.LnFeed =sal_uInt16(ChgValue(Atr0.LnFeed, 1,65535 ,FlgVal,NumVal)); break;
425 case EscSlant: AktAtr.Slant =sal_uInt16(ChgValue(Atr0.Slant, 1,MaxCharSlant ,FlgVal,NumVal)); break;
426 case EscVPos : AktAtr.ChrVPos=char (ChgValue(Atr0.ChrVPos,-128,127 ,FlgVal,NumVal)); break;
427 case EscZAbst: AktAtr.ZAbst =(sal_uInt8)(ChgValue(Atr0.ZAbst, 1,255 ,FlgVal,NumVal)); break;
428 case EscHJust: AktAtr.Justify=(sal_uInt8)(ChgValue(Atr0.Justify & 0x0F,0,5 ,FlgVal,NumVal)); break;
429 case EscFarbe: { AktAtr.L.LFarbe =(sal_uInt8)(ChgValue(Atr0.L.LFarbe,0,7 ,FlgVal,NumVal)); if (q) AktAtr.F.FFarbe =AktAtr.L.LFarbe; } break;
430 case EscBFarb: { AktAtr.L.LBFarbe=(sal_uInt8)(ChgValue(Atr0.L.LBFarbe,0,255,FlgVal,NumVal)); if (q) AktAtr.F.FBFarbe=AktAtr.L.LBFarbe; } break;
431 case EscInts : { AktAtr.L.LIntens=(sal_uInt8)(ChgValue(Atr0.L.LIntens,0,100,FlgVal,NumVal)); if (q) AktAtr.F.FIntens=AktAtr.L.LIntens; } break;
432
433 case EscMustr: { AktAtr.F.FMuster=sal_uInt16(ChgValue(Atr0.F.FMuster,0,65535,FlgVal,NumVal)); } break;
434 case EscMFarb: { AktAtr.F.FFarbe =(sal_uInt8)(ChgValue(Atr0.F.FFarbe,0,7 ,FlgVal,NumVal)); } break;
435 case EscMBFrb: { AktAtr.F.FBFarbe=(sal_uInt8)(ChgValue(Atr0.F.FBFarbe,0,255,FlgVal,NumVal)); } break;
436 case EscMInts: { AktAtr.F.FIntens=(sal_uInt8)(ChgValue(Atr0.F.FIntens,0,100,FlgVal,NumVal)); } break;
437
438 case EscSMstr: { AktAtr.ShdF.FMuster=sal_uInt16(ChgValue(Atr0.ShdF.FMuster,0,65535,FlgVal,NumVal)); } break;
439 case EscSFarb: { AktAtr.ShdL.LFarbe =(sal_uInt8)(ChgValue(Atr0.ShdL.LFarbe,0,7 ,FlgVal,NumVal)); AktAtr.ShdF.FFarbe =AktAtr.ShdL.LFarbe; } break;
440 case EscSBFrb: { AktAtr.ShdL.LBFarbe=(sal_uInt8)(ChgValue(Atr0.ShdL.LBFarbe,0,255,FlgVal,NumVal)); AktAtr.ShdF.FBFarbe=AktAtr.ShdL.LBFarbe; } break;
441 case EscSInts: { AktAtr.ShdL.LIntens=(sal_uInt8)(ChgValue(Atr0.ShdL.LIntens,0,100,FlgVal,NumVal)); AktAtr.ShdF.FIntens=AktAtr.ShdL.LIntens; } break;
442 case EscSDist: { AktAtr.ShdVers.x=(short)ChgValue(Atr0.ShdVers.x,0,30000,FlgVal,NumVal); AktAtr.ShdVers.y=AktAtr.ShdVers.x; } break;
443 case EscSXDst: { AktAtr.ShdVers.x=(short)ChgValue(Atr0.ShdVers.x,0,30000,FlgVal,NumVal); } break;
444 case EscSYDst: { AktAtr.ShdVers.y=(short)ChgValue(Atr0.ShdVers.y,0,30000,FlgVal,NumVal); } break;
445
446 case EscBold : ChgSchnittBit(TextBoldBit,0,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
447 case EscRSlnt: ChgSchnittBit(TextRSlnBit,TextLSlnBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
448 case EscUndln: ChgSchnittBit(TextUndlBit,TextDbUnBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
449 case EscStrik: ChgSchnittBit(TextStrkBit,TextDbStBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
450 case EscDbUnd: ChgSchnittBit(TextDbUnBit,TextUndlBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
451 case EscDbStk: ChgSchnittBit(TextDbStBit,TextStrkBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
452 case EscSupSc: ChgSchnittBit(TextSupSBit,TextSubSBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
453 case EscSubSc: ChgSchnittBit(TextSubSBit,TextSupSBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
454 case EscKaptF: ChgSchnittBit(TextKaptBit,0,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
455 case EscLSlnt: ChgSchnittBit(TextLSlnBit,TextRSlnBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
456 case Esc2DShd: ChgSchnittBit(TextSh2DBit,TextSh3DBit,TextSh4DBit,TextShEbBit,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
457 case Esc3DShd: ChgSchnittBit(TextSh3DBit,TextSh2DBit,TextSh4DBit,TextShEbBit,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
458 case Esc4DShd: ChgSchnittBit(TextSh4DBit,TextSh2DBit,TextSh3DBit,TextShEbBit,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
459 case EscEbShd: ChgSchnittBit(TextShEbBit,TextSh2DBit,TextSh3DBit,TextSh4DBit,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break;
460 } //endcase
461 if (TBuf[Index]==Escape) Index++; // zweites Esc weglesen }
462 } // if Ende==sal_False
463 } while (Ende==sal_False && ScanEsc==sal_False);
464 if (Ende==sal_False) c=Escape;
465 return c;
466 } // end of ProcessOne
467
468
GetTextChar(UCHAR * TBuf,sal_uInt16 & Index,ObjTextType & Atr0,ObjTextType & AktAtr,sal_uInt16 Rest,sal_Bool ScanEsc)469 UCHAR GetTextChar(UCHAR* TBuf, sal_uInt16& Index,
470 ObjTextType& Atr0, ObjTextType& AktAtr,
471 sal_uInt16 Rest, sal_Bool ScanEsc)
472 {
473 UCHAR c,c0,nc;
474
475 c=ProcessOne(TBuf,Index,Atr0,AktAtr,ScanEsc);
476 if (ScanEsc==sal_False) {
477 if (c==SoftTrennAdd || c==SoftTrennK || c==SoftTrenn) {
478 nc=GetNextChar(TBuf,Index);
479 c0=c;
480 if (Rest==0 || Rest==DoTrenn ||
481 nc==' ' || nc==AbsatzEnd || nc==TextEnd) c='-';
482 else {
483 c=ProcessOne(TBuf,Index,Atr0,AktAtr,ScanEsc); // den Trenner ueberspringen
484 if (c0==SoftTrennAdd) {
485 if (c>=32) c=ProcessOne(TBuf,Index,Atr0,AktAtr,ScanEsc); // und hier noch 'nen Buchstaben ueberspringen
486 }
487 }
488 }
489 if ((Rest==1 || Rest==DoTrenn) && GetNextChar(TBuf,Index)==SoftTrennK) {
490 if (c=='c') c='k';
491 else if (c=='C') c='K';
492 }
493 }
494 return c;
495 }
496
497 // HardSpace und HardTrenn muessen explizit konvertiert werden ! }
498 // if AktAtr.Schnitt and TextKaptBit =TextKaptBit then c:=UpCase(c);(explizit) }
499
500 // Bei der Trennmethode SoftTrennAdd wird davon ausgegangen, dass der zu }
501 // trennende Konsonant bereits 3x mal im TextBuf vorhanden ist, z.b.: }
502 // "Schiff-fahrt". Wenn nicht getrennt, dann wird "-f" entfernt. }
503
504
505
GetTextCharConv(UCHAR * TBuf,sal_uInt16 & Index,ObjTextType & Atr0,ObjTextType & AktAtr,sal_uInt16 Rest,sal_Bool ScanEsc)506 UCHAR GetTextCharConv(UCHAR* TBuf, sal_uInt16& Index,
507 ObjTextType& Atr0, ObjTextType& AktAtr,
508 sal_uInt16 Rest, sal_Bool ScanEsc)
509 {
510 UCHAR c;
511
512 c=GetTextChar(TBuf,Index,Atr0,AktAtr,Rest,ScanEsc);
513 if (c<32) {
514 switch (c) {
515 case HardSpace : c=' '; break;
516 case AbsatzEnd : c=' '; break;
517 case HardTrenn : c='-';
518 }
519 }
520 return c;
521 }
522
523
524 // ======================================================================
525 // Function GetLineFeed()
526 //
527 // Benoetigter Zeilenabstand in SGF-Units. ChrVPos wird beruecksichtigt.
528 // ======================================================================
GetLineFeed(UCHAR * TBuf,sal_uInt16 Index,ObjTextType Atr0,ObjTextType AktAtr,sal_uInt16 nChar,sal_uInt16 & LF,sal_uInt16 & MaxGrad)529 sal_uInt16 GetLineFeed(UCHAR* TBuf, sal_uInt16 Index, ObjTextType Atr0, ObjTextType AktAtr,
530 sal_uInt16 nChar, sal_uInt16& LF, sal_uInt16& MaxGrad)
531 {
532 UCHAR c=0;
533 sal_Bool AbsEnd=sal_False;
534 sal_uLong LF100=0;
535 sal_uLong MaxLF100=0;
536 sal_Bool LFauto=0;
537 sal_Bool First=sal_True;
538 sal_uInt16 Grad;
539 sal_uInt16 i=0;
540 sal_uInt16 r=1;
541
542 MaxGrad=0;
543 while (!AbsEnd && nChar>0) {
544 nChar--;
545 c=GetTextChar(TBuf,Index,Atr0,AktAtr,nChar,sal_False);
546 i++;
547 AbsEnd=(c==TextEnd || c==AbsatzEnd);
548 if (First || (!AbsEnd && c!=' ' && c!=HardTrenn)) {
549 LFauto=(AktAtr.LnFeed & 0x8000)==0;
550 LF100=AktAtr.LnFeed & 0x7FFF;
551 if (LFauto) LF100=LF100*AktAtr.Grad; else LF100*=LF100;
552 if (AktAtr.ChrVPos>0) LF100-=AktAtr.ChrVPos*100;
553 if (LF100>MaxLF100) MaxLF100=LF100;
554 Grad=AktAtr.Grad;
555 if (AktAtr.ChrVPos>0) Grad=Grad-AktAtr.ChrVPos;
556 if (Grad>MaxGrad) MaxGrad=Grad;
557 First=sal_False;
558 }
559 if (!AbsEnd && c!=' ') r=i;
560 }
561 MaxGrad=hPoint2Sgf(MaxGrad);
562 if (MaxLF100<=4000) { // sonst Overflowgefahr
563 LF=sal_uInt16(hPoint2Sgf(short(MaxLF100)) /100);
564 } else {
565 LF=sal_uInt16(hPoint2Sgf(short(MaxLF100) /100));
566 }
567
568 return r;
569 }
570
571 // End of AbsRead.Pas
572 /////////////////////////////////////////////////////////////////////////////////
573 /////////////////////////////////////////////////////////////////////////////////
574 /////////////////////////////////////////////////////////////////////////////////
575
576
577
578 /////////////////////////////////////////////////////////////////////////////////
579 /////////////////////////////////////////////////////////////////////////////////
580 /////////////////////////////////////////////////////////////////////////////////
581 // iFont.Pas
582
583 #define DefaultSlant 1500 /* Default: Italic ist 15deg */
584 #define SuperSubFact 60 /* SuperScript/SubScript: 60% vom Schriftgrad */
585 #define DefaultSpace 40 /* Default: Space ist 40% vom SchriftGrad */
586
SetTextContext(OutputDevice & rOut,ObjTextType & Atr,sal_Bool Kapt,sal_uInt16 Dreh,sal_uInt16 FitXMul,sal_uInt16 FitXDiv,sal_uInt16 FitYMul,sal_uInt16 FitYDiv)587 sal_uInt16 SetTextContext(OutputDevice& rOut, ObjTextType& Atr, sal_Bool Kapt, sal_uInt16 Dreh,
588 sal_uInt16 FitXMul, sal_uInt16 FitXDiv, sal_uInt16 FitYMul, sal_uInt16 FitYDiv)
589 {
590 SgfFontOne* pSgfFont; // Font aus dem IniFile
591 Font aFont;
592 Color aColor;
593 sal_uLong Grad;
594 sal_uLong Brei;
595 String FNam;
596 sal_uInt16 StdBrei=50; // Durchschnittliche Zeichenbreite in % von Schriftgrad
597 sal_Bool bFit=(FitXMul!=1 || FitXDiv!=1 || FitYMul!=1 || FitYDiv!=1);
598
599 pSgfFont = pSgfFonts->GetFontDesc(Atr.GetFont());
600
601 if ( pSgfFont!=NULL )
602 {
603 FNam =pSgfFont->SVFName;
604 StdBrei=pSgfFont->SVWidth;
605 if (pSgfFont->Fixd) aFont.SetPitch(PITCH_FIXED); else aFont.SetPitch(PITCH_VARIABLE);
606 aFont.SetFamily(pSgfFont->SVFamil);
607 aFont.SetCharSet(pSgfFont->SVChSet);
608 aFont.SetName(FNam);
609 }
610 else
611 { // Falls nich im Inifile, sind hier einige Fonts hart kodiert
612 aFont.SetPitch(PITCH_VARIABLE);
613 switch (Atr.GetFont()) {
614 case 92500: case 92501: case 92504: case 92505:
615 {
616 #if defined(WNT) || defined(OS2)
617 FNam=String::CreateFromAscii( "Times New Roman" ); // CG Times ist unter Windows und OS/2 Times New Roman
618 #else
619 FNam=String::CreateFromAscii( "Times" ); // ansonsten ist das einfach Times
620 #endif
621 StdBrei=40;
622 aFont.SetFamily(FAMILY_ROMAN);
623 } break;
624 case 94021: case 94022: case 94023: case 94024: {
625 #if defined(WNT)
626 FNam=String::CreateFromAscii( "Arial", 5 ); // Univers ist unter Windows Arial
627 #else
628 FNam=String::CreateFromAscii( "Helvetica" ); // und ansonsten Helvetica
629 #endif
630 aFont.SetFamily(FAMILY_SWISS);
631 StdBrei=47;
632 } break;
633 case 93950: case 93951: case 93952: case 93953: {
634 #if defined(WNT)
635 FNam=String::CreateFromAscii( "Courier New" ); // Der Vector-Courierfont unter Windows heisst Courier New
636 #else
637 FNam=String::CreateFromAscii( "Courier" ); // ansonsten ist und bleibt Courier immer Courier
638 #endif
639 aFont.SetFamily(FAMILY_ROMAN);
640 aFont.SetPitch(PITCH_FIXED);
641 } break;
642 default: FNam=String::CreateFromAscii( "Helvetica", 9 );
643 }
644 aFont.SetName(FNam);
645 //aFont.SetCharSet(CHARSET_SYSTEM);
646 }
647
648 Grad=sal_uLong(Atr.Grad);
649 if ((Atr.Schnitt & TextKaptBit) !=0 && Kapt) Grad=Grad*sal_uLong(Atr.Kapit)/100;
650 if ((Atr.Schnitt & TextSupSBit) !=0 || (Atr.Schnitt & TextSubSBit) !=0) Grad=Grad*SuperSubFact/100;
651 Brei=Grad;
652 if (Atr.Breite!=100 || bFit) {
653 if (bFit) {
654 Grad=Grad*sal_uLong(FitYMul)/sal_uLong(FitYDiv);
655 Brei=Brei*sal_uLong(FitXMul)/sal_uLong(FitXDiv);
656 }
657 Brei=Brei*sal_uLong(Atr.Breite)/100;
658 Brei=Brei*sal_uLong(StdBrei)/100;
659 aFont.SetSize(Size(hPoint2Sgf(sal_uInt16(Brei)),hPoint2Sgf(sal_uInt16(Grad))));
660 } else {
661 aFont.SetSize(Size(0,hPoint2Sgf(sal_uInt16(Grad))));
662 }
663
664 aColor=Sgv2SvFarbe(Atr.L.LFarbe,Atr.L.LBFarbe,Atr.L.LIntens); aFont.SetColor(aColor);
665 aColor=Sgv2SvFarbe(Atr.F.FFarbe,Atr.F.FBFarbe,Atr.F.FIntens); aFont.SetFillColor(aColor);
666 aFont.SetTransparent(sal_True);
667 aFont.SetAlign(ALIGN_BASELINE);
668
669 Dreh/=10; Dreh=3600-Dreh; if (Dreh==3600) Dreh=0;
670 aFont.SetOrientation(Dreh);
671
672 if ((Atr.Schnitt & TextBoldBit) !=0) aFont.SetWeight(WEIGHT_BOLD);
673 if ((Atr.Schnitt & TextRSlnBit) !=0) aFont.SetItalic(ITALIC_NORMAL);
674 if ((Atr.Schnitt & TextUndlBit) !=0) aFont.SetUnderline(UNDERLINE_SINGLE);
675 if ((Atr.Schnitt & TextDbUnBit) !=0) aFont.SetUnderline(UNDERLINE_DOUBLE);
676 if ((Atr.Schnitt & TextStrkBit) !=0) aFont.SetStrikeout(STRIKEOUT_SINGLE);
677 if ((Atr.Schnitt & TextDbStBit) !=0) aFont.SetStrikeout(STRIKEOUT_DOUBLE);
678 if ((Atr.Schnitt & TextSh2DBit) !=0) aFont.SetShadow(sal_True);
679 if ((Atr.Schnitt & TextSh3DBit) !=0) aFont.SetShadow(sal_True);
680 if ((Atr.Schnitt & TextSh4DBit) !=0) aFont.SetShadow(sal_True);
681 if ((Atr.Schnitt & TextShEbBit) !=0) aFont.SetShadow(sal_True);
682 if (CheckTextOutl(Atr.F,Atr.L)) aFont.SetOutline(sal_True);
683
684 if (aFont!=rOut.GetFont()) rOut.SetFont(aFont);
685
686 return 0;
687 }
688
689 // iFont.Pas
690 /////////////////////////////////////////////////////////////////////////////////
691 /////////////////////////////////////////////////////////////////////////////////
692 /////////////////////////////////////////////////////////////////////////////////
693
694
695 /////////////////////////////////////////////////////////////////////////////////
696 /////////////////////////////////////////////////////////////////////////////////
697 /////////////////////////////////////////////////////////////////////////////////
698 // Absatz.Pas
699
700 struct ProcChrSta {
701 sal_uInt16 Index;
702 sal_uInt16 ChrXP;
703 UCHAR OutCh;
704 sal_Bool Kapt;
705 ObjTextType Attrib;
706 };
707
InitProcessCharState(ProcChrSta & State,ObjTextType & AktAtr,sal_uInt16 IndexA)708 void InitProcessCharState(ProcChrSta& State, ObjTextType& AktAtr, sal_uInt16 IndexA)
709 {
710 State.Attrib=AktAtr;
711 State.OutCh=0;
712 State.Index=IndexA;
713 State.ChrXP=0;
714 State.Kapt=sal_False;
715 }
716
UpcasePossible(UCHAR c)717 sal_Bool UpcasePossible(UCHAR c)
718 {
719 if ((c>='a' && c<='z') || c == 0xe4 || c == 0xf6 || c == 0xfc ) return sal_True;
720 else return sal_False;
721 }
722
Upcase(UCHAR c)723 UCHAR Upcase(UCHAR c)
724 {
725 if ((c>=(UCHAR)'a' && c<=(UCHAR)'z')) c=(c-(UCHAR)'a')+(UCHAR)'A';
726 else if ( c == 0xe4 ) c = 0xc4;
727 else if ( c == 0xf6 ) c = 0xd6;
728 else if ( c == 0xfc ) c = 0xdc;
729 return c;
730 }
731
GetCharWidth(OutputDevice & rOut,UCHAR c)732 sal_uInt16 GetCharWidth(OutputDevice& rOut, UCHAR c)
733 {
734 UCHAR c1;
735 sal_uInt16 ChrWidth;
736
737 c1 = ByteString::Convert((char)c,RTL_TEXTENCODING_IBM_437, gsl_getSystemTextEncoding() );
738 if (c==' ')
739 {
740 ChrWidth=(sal_uInt16)rOut.GetTextWidth( String('A') );
741 if (rOut.GetFont().GetPitch()!=PITCH_FIXED) {
742 ChrWidth=MulDiv(ChrWidth,DefaultSpace,100);
743 }
744 } else {
745 // with MaxChar == 255 c cannot be greater than MaxChar
746 // assert if MaxChar is ever changed
747 OSL_ENSURE( MaxChar == 255, "MaxChar not 255" );
748 if (c>=MinChar /*&& c<=MaxChar*/)
749 {
750 ChrWidth=(sal_uInt16)rOut.GetTextWidth(String((char)c1));
751 }
752 else
753 {
754 ChrWidth=(sal_uInt16)rOut.GetTextWidth(String('A'));
755 }
756 }
757 return ChrWidth;
758 }
759
ProcessChar(OutputDevice & rOut,UCHAR * TBuf,ProcChrSta & R,ObjTextType & Atr0,sal_uInt16 & nChars,sal_uInt16 Rest,short * Line,UCHAR * cLine)760 UCHAR ProcessChar(OutputDevice& rOut, UCHAR* TBuf, ProcChrSta& R, ObjTextType& Atr0,
761 sal_uInt16& nChars, sal_uInt16 Rest,
762 short* Line, UCHAR* cLine)
763 {
764 sal_uInt16 KernDist=0; // Wert fuer Kerning
765 sal_uInt16 ChrWidth;
766 UCHAR c;
767 UCHAR c1;
768 sal_Bool AbsEnd;
769
770 c=GetTextChar(TBuf,R.Index,Atr0,R.Attrib,Rest,sal_False); // versucht evtl. zu trennen, wenn Rest entsprechenden Wert besitzt
771
772 AbsEnd=(c==AbsatzEnd || c==TextEnd);
773 if (AbsEnd==sal_False) {
774 R.OutCh=ConvertTextChar(c); // von HardTrenn nach '-', ...
775 R.Kapt=(R.Attrib.Schnitt & TextKaptBit) !=0 && UpcasePossible(R.OutCh);
776 if (R.Kapt) R.OutCh=Upcase(R.OutCh);
777 SetTextContext(rOut,R.Attrib,R.Kapt,0,1,1,1,1);
778
779 if (R.Kapt) c1=Upcase(c); else c1=c;
780 ChrWidth=GetCharWidth(rOut,c1);
781
782 if (R.Attrib.ZAbst!=100) { // Spezial-Zeichenabstand ?
783 sal_uLong Temp;
784 Temp=sal_uLong(ChrWidth)*sal_uLong(R.Attrib.ZAbst)/100;
785 ChrWidth=sal_uInt16(Temp);
786 }
787 nChars++;
788 if (R.ChrXP>32000) R.ChrXP=32000;
789 Line[nChars]=R.ChrXP-KernDist;
790 cLine[nChars]=c;
791 R.ChrXP+=ChrWidth-KernDist; // Position fuer den naechsten Character
792 }
793 return c;
794 }
795
FormatLine(UCHAR * TBuf,sal_uInt16 & Index,ObjTextType & Atr0,ObjTextType & AktAtr,sal_uInt16 UmbWdt,sal_uInt16 AdjWdt,short * Line,sal_uInt16 & nChars,double,double,UCHAR * cLine,sal_Bool TextFit)796 void FormatLine(UCHAR* TBuf, sal_uInt16& Index, ObjTextType& Atr0, ObjTextType& AktAtr,
797 sal_uInt16 UmbWdt, sal_uInt16 AdjWdt,
798 short* Line, sal_uInt16& nChars,
799 double, double,
800 UCHAR* cLine, sal_Bool TextFit)
801 {
802 VirtualDevice vOut;
803 UCHAR c,c0;
804 UCHAR ct;
805 sal_Bool First; // erster Char ?
806 sal_uInt8 Just = 0; // Absatzformatierung
807 sal_Bool Border; // Rand der Box erreicht ?
808 sal_Bool Border0;
809 sal_Bool AbsEnd; // Ende des Absatzes erreicht ?
810 ProcChrSta* R=new ProcChrSta;
811 ProcChrSta* R0=new ProcChrSta;
812 ProcChrSta* WErec=new ProcChrSta;
813 sal_uInt16 WEnChar;
814 ProcChrSta* WErec0=new ProcChrSta;
815 sal_uInt16 WEnChar0;
816 ProcChrSta* TRrec=new ProcChrSta;
817 sal_uInt16 TRnChar;
818
819 sal_uInt16 WordEndCnt; // Justieren und Trennen
820 sal_Bool WordEnd;
821 sal_Bool Trenn;
822
823 short BoxRest; // zum Quetschen und formatieren
824 sal_uInt16 i,j,k,h;
825 sal_uInt16 re,li;
826
827 vOut.SetMapMode(MapMode(MAP_10TH_MM,Point(),Fraction(1,4),Fraction(1,4)));
828
829 nChars=0;
830 SetTextContext(vOut,AktAtr,sal_False,0,1,1,1,1);
831 InitProcessCharState(*R,AktAtr,Index);
832 (*R0)=(*R); (*WErec)=(*R); WEnChar=0; c0=0; Border0=sal_False;
833 Border=sal_False; First=sal_True;
834 WordEndCnt=0;
835
836 do { // mal schauen, wieviele Worte so in die Zeile passen
837 if (Border) c=ProcessChar(vOut,TBuf,*R,Atr0,nChars,DoTrenn,Line,cLine);
838 else c=ProcessChar(vOut,TBuf,*R,Atr0,nChars,NoTrenn,Line,cLine);
839 AbsEnd=(c==AbsatzEnd || c==TextEnd);
840 //if not AbsEnd then
841 {
842 if (First) {
843 Just=R->Attrib.Justify & 0x0F; // Absatzformat steht wenn, dann am Anfang
844 }
845 Border=R->ChrXP>UmbWdt;
846 WordEnd=(AbsEnd || (c==' ')) && (c0!=' ') && (c0!=0);
847 Trenn=c=='-';
848 if (WordEnd && !Border0) {
849 WordEndCnt++;
850 (*WErec)=(*R0);
851 WEnChar=nChars-1;
852 }
853 if (Trenn && !Border) {
854 WordEndCnt++;
855 (*WErec)=(*R);
856 WEnChar=nChars;
857 }
858 }
859 (*R0)=(*R); c0=c;
860 Border0=Border;
861 First=sal_False;
862 AbsEnd=AbsEnd || (nChars>=MaxLineChars);
863 } while (!(AbsEnd || (Border && ((WordEndCnt>0) || WordEnd || Trenn))));
864
865 if (Border) { // Trennen und Quetschen
866 (*WErec0)=(*WErec); WEnChar0=WEnChar;
867 AbsEnd=sal_False; c0=0;
868 (*R)=(*WErec); nChars=WEnChar;
869 (*TRrec)=(*R); TRnChar=nChars;
870 Border0=sal_False; Border=sal_False;
871 do { // erst mal gucken wieviele Silben noch reinpassen
872 ct=ProcessChar(vOut,TBuf,*TRrec,Atr0,TRnChar,DoTrenn,Line,cLine);
873 c=ProcessChar(vOut,TBuf,*R,Atr0,nChars,NoTrenn,Line,cLine);
874 AbsEnd=(ct==AbsatzEnd) || (ct==TextEnd) || (nChars>=MaxLineChars);
875
876 Border=TRrec->ChrXP>UmbWdt;
877 WordEnd=AbsEnd || ((AbsEnd || (c==' ')) && (c0!=' ') && (c0!=0));
878 Trenn=ct=='-';
879 if (WordEnd && (!Border0 || (WordEndCnt==0))) {
880 WordEndCnt++;
881 (*WErec)=(*R0);
882 if (AbsEnd) WEnChar=nChars; else WEnChar=nChars-1;
883 (*TRrec)=(*R); TRnChar=nChars; // zum weitersuchen
884 }
885 if (Trenn && (!Border || (WordEndCnt==0))) {
886 WordEndCnt++; // merken, dass man hier trennen kann
887 (*WErec)=(*TRrec);
888 WEnChar=TRnChar;
889 (*TRrec)=(*R); TRnChar=nChars; // zum weitersuchen
890 }
891 (*R0)=(*R); c0=c;
892 Border0=Border;
893 Border=R->ChrXP>UmbWdt;
894 } while (!(AbsEnd || (Border && ((WordEndCnt>0) || WordEnd || Trenn))));
895
896 while (WErec0->Index<WErec->Index) { // damit Line[] auch garantiert stimmt }
897 c=ProcessChar(vOut,TBuf,*WErec0,Atr0,WEnChar0,WEnChar-WEnChar0-1,Line,cLine);
898 }
899
900 (*R)=(*WErec); nChars=WEnChar;
901
902 if (UmbWdt>=R->ChrXP) {
903 BoxRest=UmbWdt-R->ChrXP;
904 } else { // Zusammenquetschen
905 BoxRest=R->ChrXP-UmbWdt; // um soviel muss gequetscht werden
906 for (i=2;i<=nChars;i++) { // 1. CharPosition bleibt !
907 Line[i]-=(i-1)*(BoxRest) /(nChars-1);
908 }
909 R->ChrXP=UmbWdt;
910 Line[nChars+1]=UmbWdt;
911 }
912 }
913
914 if (!AbsEnd) {
915 do { // Leerzeichen weglesen
916 (*WErec)=(*R);
917 c=GetTextChar(TBuf,R->Index,Atr0,R->Attrib,NoTrenn,sal_False);
918 nChars++;
919 Line[nChars]=R->ChrXP;
920 cLine[nChars]=c;
921 } while (c==' ');
922 if (c!=' ' && c!=AbsatzEnd && c!=TextEnd) {
923 nChars--;
924 (*R)=(*WErec);
925 }
926 }
927
928 if (AbsEnd && nChars<MaxLineChars) { // Ausrichten, statt Blocksatz aber linksbuendig
929 if (Just==3) Just=0;
930 nChars++; Line[nChars]=R->ChrXP; // Damit AbsatzEnde auch weggelesen wird
931 Line[nChars+1]=R->ChrXP; // denn die Breite von CR oder #0 ist nun mal sehr klein
932 if (TBuf[R->Index-1]!=AbsatzEnd && TBuf[R->Index-1]!=TextEnd) {
933 c=GetTextChar(TBuf,R->Index,Atr0,R->Attrib,NoTrenn,sal_False); // Kleine Korrektur. Notig, wenn nur 1 Wort in
934 }
935 }
936
937 BoxRest=AdjWdt-R->ChrXP;
938 if (TextFit) Just=THJustLeft;
939
940 switch (Just) {
941 case THJustLeft: break; // Links
942 case THJustCenter: {
943 BoxRest=BoxRest /2; // Mitte
944 for (i=1;i<=nChars;i++) Line[i]=Line[i]+BoxRest;
945 } break;
946 case THJustRight: { // Rechts
947 for (i=1;i<=nChars;i++) Line[i]=Line[i]+BoxRest;
948 } break;
949 case THJustDrvOut:
950 case THJustBlock: { // Block und Austreibend
951 re=nChars;
952 if (Just==THJustDrvOut) re--;
953 while (re>=1 && (cLine[re]==' ' || cLine[re]==TextEnd || cLine[re]==AbsatzEnd)) re--;
954 li=1;
955 while (li<=re && (cLine[li]==' ' || cLine[li]==TextEnd || cLine[li]==AbsatzEnd)) li++;
956 if (Just==THJustDrvOut) BoxRest=AdjWdt-Line[re+1];
957
958 j=0; // Anzahl der Spaces ermitteln
959 for (i=li;i<=re;i++) {
960 if (cLine[i]==' ') {
961 j++;
962 }
963 }
964
965 if (j==0) { // nur 1 Wort ? -> Strecken !
966 for (i=li+1;i<=re;i++) { // von links nach rechts
967 Line[i]=Line[i]+MulDiv(i-li,BoxRest,re-li+1-1);
968 }
969 } else {
970 k=0; h=0;
971 for (i=li;i<=re;i++) { // j Spaces aufbohren !
972 if (cLine[i]==' ') { // Space gefunden !
973 k++;
974 h=MulDiv(k,BoxRest,j);
975 }
976 Line[i]=Line[i]+h;
977 }
978 }
979 for (i=re+1;i<=nChars;i++) Line[i]=Line[i]+BoxRest; // und den Rest anpassen
980 Line[nChars+1]=AdjWdt;
981 } break;
982 case THJustLocked: { //Gesperrt
983 re=nChars-1;
984 while (re>=1 && (cLine[re]==' ' || cLine[re]==TextEnd || cLine[re]==AbsatzEnd)) re--;
985 li=1;
986 while (li<=re && (cLine[li]==' ' || cLine[li]==TextEnd || cLine[li]==AbsatzEnd)) li++;
987 BoxRest=AdjWdt-Line[re+1];
988 for (i=li+1;i<=re;i++) { // Strecken von links nach rechts
989 Line[i]=Line[i]+MulDiv(i-li,BoxRest,re-li+1-1);
990 }
991 for (i=re+1;i<=nChars;i++) Line[i]=Line[i]+BoxRest; // und den Rest anpassen
992 Line[nChars+1]=AdjWdt;
993 } break;
994 }
995 Index=R->Index;
996 AktAtr=R->Attrib;
997 delete R;
998 delete R0;
999 delete WErec;
1000 delete WErec0;
1001 delete TRrec;
1002 }
1003
1004
1005
1006 // End of Absatz.Pas
1007 /////////////////////////////////////////////////////////////////////////////////
1008 /////////////////////////////////////////////////////////////////////////////////
1009 /////////////////////////////////////////////////////////////////////////////////
1010
1011
1012 /////////////////////////////////////////////////////////////////////////////////
1013 /////////////////////////////////////////////////////////////////////////////////
1014 /////////////////////////////////////////////////////////////////////////////////
1015 // DrawText.Pas
1016
DrawChar(OutputDevice & rOut,UCHAR c,ObjTextType T,PointType Pos,sal_uInt16 DrehWink,sal_uInt16 FitXMul,sal_uInt16 FitXDiv,sal_uInt16 FitYMul,sal_uInt16 FitYDiv)1017 void DrawChar(OutputDevice& rOut, UCHAR c, ObjTextType T, PointType Pos, sal_uInt16 DrehWink,
1018 sal_uInt16 FitXMul, sal_uInt16 FitXDiv, sal_uInt16 FitYMul, sal_uInt16 FitYDiv)
1019 {
1020 SetTextContext(rOut,T,UpcasePossible(c),DrehWink,FitXMul,FitXDiv,FitYMul,FitYDiv);
1021 if ((T.Schnitt & TextKaptBit)!=0 && UpcasePossible(c)) c=Upcase(c);
1022 String s( (char)c, RTL_TEXTENCODING_IBM_437 );
1023 rOut.DrawText( Point( Pos.x, Pos.y ), s );
1024 }
1025
1026 /*************************************************************************
1027 |*
1028 |* TextType::Draw()
1029 |*
1030 |* Beschreibung
1031 |* Ersterstellung JOE 09.08.93
1032 |* Letzte Aenderung JOE 09.08.93
1033 |*
1034 *************************************************************************/
Draw(OutputDevice & rOut)1035 void TextType::Draw(OutputDevice& rOut)
1036 {
1037 if ((Flags & TextOutlBit)!=0) return; // Sourcetext fuer Outliner !!
1038
1039 ObjTextType T1,T2;
1040 sal_uInt16 Index1;
1041 sal_uInt16 Index2;
1042 UCHAR c = TextEnd;
1043 sal_uInt16 l; // Anzahl der Zeichen in der Zeile
1044 sal_uInt16 i;
1045 short yPos0;
1046 short xPos;
1047 short yPos;
1048 sal_uInt16 LF;
1049 sal_uInt16 MaxGrad;
1050 short xSize;
1051 short xSAdj;
1052 short ySize;
1053 double sn,cs;
1054 sal_uInt16 TopToBase;
1055 sal_Bool Ende = 0;
1056 sal_uInt16 lc;
1057 sal_Bool LineFit; // FitSize.x=0? oder Flags -> jede Zeile stretchen
1058 sal_Bool TextFit;
1059 short* xLine;
1060 UCHAR* cLine; // Buffer fuer FormatLine
1061 sal_uInt16 FitXMul;
1062 sal_uInt16 FitXDiv;
1063 sal_uInt16 FitYMul;
1064 sal_uInt16 FitYDiv;
1065 sal_Bool Fehler;
1066 UCHAR* Buf=Buffer; // Zeiger auf die Buchstaben
1067
1068 pSgfFonts->ReadList();
1069 xLine=new short[ChrXPosArrSize];
1070 cLine=new UCHAR[CharLineSize];
1071
1072 TextFit=(Flags & TextFitBits)!=0;
1073 LineFit=sal_False;
1074 LineFit=((Flags & TextFitZBit)!=0);
1075 if (TextFit && FitSize.x==0) LineFit=sal_True;
1076
1077 if (DrehWink==0) {
1078 sn=0.0;
1079 cs=1.0;
1080 } else {
1081 sn=sin(double(DrehWink)*3.14159265359/18000);
1082 cs=cos(double(DrehWink)*3.14159265359/18000);
1083 }
1084
1085 T1=T; Index1=0; yPos=0; xPos=0;
1086 if (TextFit) {
1087 ySize=Pos2.y-Pos1.y;
1088 xSize=32000 /2; // Umbruch
1089 xSAdj=Pos2.x-Pos1.x; // zum Ausrichten bei Zentriert/Blocksatz
1090 //if (xSize<=0) { xSize=32000 /2; LineFit=sal_True; }
1091 FitXMul=sal::static_int_cast< sal_uInt16 >(abs(Pos2.x-Pos1.x)); FitXDiv=FitSize.x; if (FitXDiv==0) FitXDiv=1;
1092 FitYMul=sal::static_int_cast< sal_uInt16 >(abs(Pos2.y-Pos1.y)); FitYDiv=FitSize.y; if (FitYDiv==0) FitYDiv=1;
1093 } else {
1094 xSize=Pos2.x-Pos1.x;
1095 xSAdj=xSize;
1096 ySize=Pos2.y-Pos1.y;
1097 FitXMul=1; FitXDiv=1;
1098 FitYMul=1; FitYDiv=1;
1099 }
1100 if (xSize<0) xSize=0;
1101 if (xSAdj<0) xSAdj=0;
1102
1103 do {
1104 T2=T1; Index2=Index1;
1105 FormatLine(Buf,Index2,T,T2,xSize,xSAdj,xLine,l,sn,cs,cLine,LineFit);
1106 Fehler=(Index2==Index1);
1107 if (!Fehler) {
1108 lc=GetLineFeed(Buf,Index1,T,T1,l,LF,MaxGrad);
1109 if (TextFit) {
1110 if (LineFit) FitXDiv=xLine[lc+1];
1111 if (FitXDiv>0) {
1112 long Temp;
1113 for (i=1;i<=l+1;i++) {
1114 Temp=long(xLine[i])*long(FitXMul) /long(FitXDiv);
1115 xLine[i]=short(Temp);
1116 }
1117 LF=MulDiv(LF,FitYMul,FitYDiv);
1118 MaxGrad=MulDiv(MaxGrad,FitYMul,FitYDiv);
1119 } else {
1120 FitXDiv=1; // 0 gibts nicht
1121 }
1122 }
1123 yPos0=yPos;
1124 TopToBase=GetTopToBaseLine(MaxGrad);
1125 yPos=yPos+TopToBase;
1126 Ende=(yPos0+short(MulDiv(MaxGrad,CharTopToBtm,100))>ySize) && !TextFit;
1127 if (!Ende) {
1128 T2=T1; Index2=Index1;
1129 i=1;
1130 while (i<=l) {
1131 c=GetTextCharConv(Buf,Index2,T,T2,l-i,sal_False);
1132 long xp1,yp1; // wegen Overflowgefahr
1133 PointType Pos;
1134 xp1=long(Pos1.x)+xPos+long(xLine[i]);
1135 yp1=long(Pos1.y)+yPos;
1136 if (xp1>32000) xp1=32000; if (xp1<-12000) xp1=-12000;
1137 if (yp1>32000) yp1=32000; if (yp1<-12000) yp1=-12000;
1138 Pos.x=short(xp1);
1139 Pos.y=short(yp1);
1140
1141 if (DrehWink!=0) RotatePoint(Pos,Pos1.x,Pos1.y,sn,cs);
1142 DrawChar(rOut,c,T2,Pos,DrehWink,FitXMul,FitXDiv,FitYMul,FitYDiv);
1143 i++;
1144 } // while i<=l
1145 yPos=yPos0+LF;
1146 T1=T2; Index1=Index2; // Fuer die naechste Zeile
1147 } // if ObjMin.y+yPos<=Obj_Max.y
1148 } // if !Fehler
1149 } while (c!=TextEnd && !Ende && !Fehler);
1150 delete[] cLine;
1151 delete[] xLine;
1152 }
1153
1154 // End of DrawText.Pas
1155 /////////////////////////////////////////////////////////////////////////////////
1156 /////////////////////////////////////////////////////////////////////////////////
1157 /////////////////////////////////////////////////////////////////////////////////
1158
1159 // nicht mehr benoetigt, da der Pointer nun extra gefuehrt wird
1160 // (DEC Alpha hat naemlich 64Bit-Pointer!)
1161 //UCHAR* TextType::GetBufPtr()
1162 //{
1163 // sal_uLong Temp;
1164 // Temp=sal_uLong(BufLo)+0x00010000*sal_uLong(BufHi);
1165 // return (UCHAR*)Temp;
1166 //}
1167 //
1168 //void TextType::SetBufPtr(UCHAR* Ptr)
1169 //{
1170 // sal_uLong Temp=(sal_uLong)Ptr;
1171 // BufLo=sal_uInt16(Temp & 0x0000FFFF);
1172 // BufHi=sal_uInt16((Temp & 0xFFFF0000)>>16);
1173 //}
1174
GetFont()1175 sal_uInt32 ObjTextType::GetFont()
1176 {
1177 return sal_uLong(FontLo)+0x00010000*sal_uLong(FontHi);
1178 }
1179
SetFont(sal_uInt32 FontID)1180 void ObjTextType::SetFont(sal_uInt32 FontID)
1181 {
1182 FontLo=sal_uInt16(FontID & 0x0000FFFF);
1183 FontHi=sal_uInt16((FontID & 0xFFFF0000)>>16);
1184 }
1185
1186
1187 /////////////////////////////////////////////////////////////////////////////////
1188 // SGF.Ini lesen ////////////////////////////////////////////////////////////////
1189 /////////////////////////////////////////////////////////////////////////////////
SgfFontOne()1190 SgfFontOne::SgfFontOne()
1191 {
1192 Next=NULL;
1193 IFID=0;
1194 Bold=sal_False;
1195 Ital=sal_False;
1196 Sans=sal_False;
1197 Serf=sal_False;
1198 Fixd=sal_False;
1199 SVFamil=FAMILY_DONTKNOW;
1200 SVChSet=RTL_TEXTENCODING_DONTKNOW;
1201 SVWidth=40;
1202 }
1203
ReadOne(ByteString & ID,ByteString & Dsc)1204 void SgfFontOne::ReadOne( ByteString& ID, ByteString& Dsc )
1205 {
1206 sal_uInt16 i,j,n;
1207 ByteString s;
1208
1209 if ( Dsc.Len() < 4 || ( Dsc.GetChar( 0 ) != '(' ) )
1210 return;
1211 i=1; // Erster Buchstabe des IF-Fontnamen. Davor ist eine '('
1212 while ( i < Dsc.Len() && ( Dsc.GetChar( i ) !=')' ) )
1213 i++;
1214 Dsc.Erase(0,i+1); // IF-Fontname loeschen inkl. ()
1215
1216 if ( Dsc.Len() < 2 || ( Dsc.GetChar( Dsc.Len() - 1 ) !=')' ) )
1217 return;
1218 i=Dsc.Len()-2; // hier ist die ')' des SV-Fontnames
1219 j=0;
1220 while ( i > 0 && ( Dsc.GetChar( i ) != '(' ) )
1221 {
1222 i--;
1223 j++;
1224 }
1225 SVFName=String(Dsc,i+1,j); // SV-Fontname rausholen
1226 Dsc.Erase(i,j);
1227
1228 IFID = (sal_uInt32)ID.ToInt32();
1229 n=Dsc.GetTokenCount(' ');
1230 for (i=0;i<n;i++)
1231 {
1232 s = Dsc.GetToken( i,' ' );
1233 if ( s.Len() )
1234 {
1235 s.ToUpperAscii();
1236 if ( s.CompareTo( "BOLD", 4 ) == COMPARE_EQUAL ) Bold=sal_True;
1237 else if ( s.CompareTo( "ITAL", 4 ) == COMPARE_EQUAL ) Ital=sal_True;
1238 else if ( s.CompareTo( "SERF", 4 ) == COMPARE_EQUAL ) Serf=sal_True;
1239 else if ( s.CompareTo( "SANS", 4 ) == COMPARE_EQUAL ) Sans=sal_True;
1240 else if ( s.CompareTo( "FIXD", 4 ) == COMPARE_EQUAL ) Fixd=sal_True;
1241 else if ( s.CompareTo( "ROMAN", 5 ) == COMPARE_EQUAL ) SVFamil=FAMILY_ROMAN;
1242 else if ( s.CompareTo( "SWISS", 5 ) == COMPARE_EQUAL ) SVFamil=FAMILY_SWISS;
1243 else if ( s.CompareTo( "MODERN", 6 ) == COMPARE_EQUAL ) SVFamil=FAMILY_MODERN;
1244 else if ( s.CompareTo( "SCRIPT", 6 ) == COMPARE_EQUAL ) SVFamil=FAMILY_SCRIPT;
1245 else if ( s.CompareTo( "DECORA", 6 ) == COMPARE_EQUAL ) SVFamil=FAMILY_DECORATIVE;
1246 else if ( s.CompareTo( "ANSI", 4 ) == COMPARE_EQUAL ) SVChSet=RTL_TEXTENCODING_MS_1252;
1247 else if ( s.CompareTo( "IBMPC", 5 ) == COMPARE_EQUAL ) SVChSet=RTL_TEXTENCODING_IBM_850;
1248 else if ( s.CompareTo( "MAC", 3 ) == COMPARE_EQUAL ) SVChSet=RTL_TEXTENCODING_APPLE_ROMAN;
1249 else if ( s.CompareTo( "SYMBOL", 6 ) == COMPARE_EQUAL ) SVChSet=RTL_TEXTENCODING_SYMBOL;
1250 else if ( s.CompareTo( "SYSTEM", 6 ) == COMPARE_EQUAL ) SVChSet = gsl_getSystemTextEncoding();
1251 else if ( s.IsNumericAscii() ) SVWidth=sal::static_int_cast< sal_uInt16 >(s.ToInt32());
1252 }
1253 }
1254 }
1255
1256 /////////////////////////////////////////////////////////////////////////////////
1257
SgfFontLst()1258 SgfFontLst::SgfFontLst()
1259 {
1260 pList=NULL;
1261 Last=NULL;
1262 LastID=0;
1263 LastLn=NULL;
1264 Tried=sal_False;
1265 }
1266
~SgfFontLst()1267 SgfFontLst::~SgfFontLst()
1268 {
1269 RausList();
1270 }
1271
RausList()1272 void SgfFontLst::RausList()
1273 {
1274 SgfFontOne* P;
1275 SgfFontOne* P1;
1276 P=pList;
1277 while (P!=NULL) {
1278 P1=P->Next;
1279 delete P;
1280 P=P1;
1281 }
1282 pList=NULL;
1283 Last=NULL;
1284 Tried=sal_False;
1285 LastID=0;
1286 LastLn=NULL;
1287 }
1288
AssignFN(const String & rFName)1289 void SgfFontLst::AssignFN(const String& rFName)
1290 { FNam=rFName; }
1291
ReadList()1292 void SgfFontLst::ReadList()
1293 {
1294 if (!Tried) {
1295 Tried=sal_True;
1296 LastID=0;
1297 LastLn=NULL;
1298 SgfFontOne* P,P1;
1299 Config aCfg(FNam);
1300 aCfg.SetGroup("SGV Fonts fuer StarView");
1301 sal_uInt16 Anz=aCfg.GetKeyCount();
1302 sal_uInt16 i;
1303 ByteString FID,Dsc;
1304
1305 for (i=0;i<Anz;i++)
1306 {
1307 FID = aCfg.GetKeyName( i );
1308 FID = FID.EraseAllChars(); // Leerzeichen weg
1309 Dsc = aCfg.ReadKey( i );
1310 if ( FID.IsNumericAscii() )
1311 {
1312 P=new SgfFontOne; // neuer Eintrag
1313 if (Last!=NULL) Last->Next=P; else pList=P; Last=P; // einklinken
1314 P->ReadOne(FID,Dsc); // und Zeile interpretieren
1315 }
1316 }
1317 }
1318 }
1319
GetFontDesc(sal_uInt32 ID)1320 SgfFontOne* SgfFontLst::GetFontDesc(sal_uInt32 ID)
1321 {
1322 if (ID!=LastID) {
1323 SgfFontOne* P;
1324 P=pList;
1325 while (P!=NULL && P->IFID!=ID) P=P->Next;
1326 LastID=ID;
1327 LastLn=P;
1328 }
1329 return LastLn;
1330 }
1331