| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svtools.hxx" |
| |
| #include <rtl/math.h> |
| #include <tools/config.hxx> |
| #include <svtools/filter.hxx> |
| #include "sgffilt.hxx" |
| #include "sgfbram.hxx" |
| #include "sgvmain.hxx" |
| // #include "Debug.c" |
| |
| extern SgfFontLst* pSgfFonts; |
| |
| #ifndef abs |
| #define abs(x) ((x)<0 ? -(x) : (x)) |
| #endif |
| |
| |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| // |
| // Einschraenkungen: Schatten nur grau, 2D und mit fixem Abstand. |
| // |
| // |
| // |
| // |
| //////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| // AbsBase.Pas |
| |
| // die folgenden Werte sind in % vom maximalen Schriftgrad der Zeile */ |
| #define UndlSpace 5 /* Untersteichungsabstand von der Baseline */ |
| #define UndlWidth 6 /* Untersteichungsdicke */ |
| #define UndlSpac2 7 /* Zwischenraum bei doppelter Unterstreichung */ |
| #define StrkSpace 25 /* Abstand der Durchstreichlinie von der Baseline*/ |
| #define StrkWidth 5 /* Durchstreichungsliniendicke */ |
| #define StrkSpac2 7 /* Zwischenraum bei doppelter Durchstreichung */ |
| #define OutlWidth 2 /* Strichstaerke ist 2% vom Schriftgrad */ |
| |
| // vvv Sonderzeichen im TextBuffer vvv |
| #define TextEnd 0 /* ^@ Ende der Zeichenkette */ |
| #define HardSpace 6 /* ^F Hartspace (wird nicht umbrochen) ,' ' */ |
| #define GrafText 7 /* ^G Im Text eingebundene Grafik (future) */ |
| #define Tabulator 9 /* ^I Tabulatorzeichen, Pfeil */ |
| #define LineFeed 10 /* ^J Neue Zeile */ |
| #define SoftTrennK 11 /* ^K Zeichen fuer k-c-Austausch bei Trennung, 'k' */ |
| #define AbsatzEnd 13 /* ^M Neuer Absatz =CR */ |
| #define HardTrenn 16 /* ^P Hartes Trennzeichen (wird nicht umbrochen), '-' */ |
| #define SoftTrennAdd 19 /* ^S Zusatz-Zeichen Trennung von z.b."Schiff-fahrt" */ |
| #define Paragraf 21 /* ^U Zeichen welches fuer Paragraf-Zeichen */ |
| #define Escape 27 /* ^[ Escapesequenz einleiten */ |
| #define SoftTrenn 31 /* ^_ Weiches Trennzeichen, '-' nur Zeilenende */ |
| #define MaxEscValLen 8 |
| #define MaxEscLen (MaxEscValLen+3) |
| |
| //============================================================================== |
| // Escapesequenzen: [Esc]<Ident><Value>[Esc] also mind. 4 Char |
| // Max. Laenge von Value soll sein: 8 Char (7+Vorzeichen). Demnach max. Laenge |
| // einer Escapesequenz: 11 Char. |
| // Identifer: |
| |
| #define EscFont 'F' /* FontID, z.B. 92500 fuer CG Times */ |
| #define EscGrad 'G' /* Schriftgrad 1..255 fuer <<Pt-127<<Pt */ |
| #define EscBreit 'B' /* Breite 1..255% des Schriftgrades */ |
| #define EscKaptS 'K' /* Kapitaelchengroesse 1..255% des Schriftgrades */ |
| #define EscLFeed 'L' /* Zeilenabstand 1..32767% vom max. Schriftgrad der Zeile */ |
| // oder 1..32767 fuer 1..16383<<Pt absolut (Wenn Bit 15=1) |
| #define EscSlant 'S' /* Kursiv(Winkel) 1..8999 fuer 0.01deg..89.99deg */ |
| #define EscVPos 'V' /* Zeichen Vertikal-Position 1..255 fuer <<Pt..127<<Pt */ |
| #define EscZAbst 'Z' /* Zeichenabstand -128..127% */ |
| #define EscHJust 'A' /* H-Justify Absatz: Links, Zentr, Rechts, Block, Austreibend, Gesperrt (0..5)*/ |
| |
| #define EscFarbe 'C' /* Farbe 0..7 */ |
| #define EscBFarb 'U' /* BackFarbe 0..7 */ |
| #define EscInts 'I' /* Farbintensitaet 0..100% */ |
| #define EscMustr 'M' /* Muster 0..? inkl. Transp... */ |
| #define EscMFarb 'O' /* Musterfarbe 0..7 */ |
| #define EscMBFrb 'P' /* 2. Musterfarbe 0..7 */ |
| #define EscMInts 'W' /* Musterintensitaet 0..7 */ |
| |
| #define EscSMstr 'E' /* Schattenmuster 0..? inkl. Transp... */ |
| #define EscSFarb 'R' /* Schattenfarbe 0..7 */ |
| #define EscSBFrb 'T' /* 2. Schattenfarbe 0..7 */ |
| #define EscSInts 'Q' /* Schattenintensitaet 0..7 */ |
| |
| #define EscSXDst 'X' /* Schattenversatz X 0..100% */ |
| #define EscSYDst 'Y' /* Schattenversatz Y 0..100% */ |
| #define EscSDist 'D' /* Schattenversatz X-Y 0..100% */ |
| |
| #define EscBold 'f' /* Fett */ |
| #define EscLSlnt 'l' /* LKursiv */ |
| #define EscRSlnt 'r' /* RKursiv */ |
| #define EscUndln 'u' /* Unterstrichen */ |
| #define EscDbUnd 'p' /* doppelt Unterstrichen */ |
| #define EscKaptF 'k' /* Kapitaelchenflag */ |
| #define EscStrik 'd' /* Durchgestrichen */ |
| #define EscDbStk 'e' /* doppelt Durchgestrichen */ |
| #define EscSupSc 'h' /* Hochgestellt */ |
| #define EscSubSc 't' /* Tiefgestellt */ |
| #define Esc2DShd 's' /* 2D-Schatten */ |
| #define Esc3DShd 'j' /* 3D-Schatten */ |
| #define Esc4DShd 'i' /* 4D-Schatten */ |
| #define EscEbShd 'b' /* Embossed */ |
| |
| // AllEscIdent =[EscFont, EscGrad, EscBreit,EscKaptS,EscLFeed,EscSlant,EscVPos, EscZAbst,EscHJust, |
| // EscFarbe,EscBFarb,EscInts, EscMustr,EscMFarb,EscMBFrb,EscMInts, |
| // EscSMstr,EscSFarb,EscSBFrb,EscSInts,EscSXDst,EscSYDst,EscSDist, |
| // EscBold, EscLSlnt,EscRSlnt,EscUndln,EscDbUnd,EscKaptF,EscStrik,EscDbStk, |
| // EscSupSc,EscSubSc,Esc2DShd,Esc3DShd,Esc4DShd]; |
| // Justify muss spaetestens am Anfang des Absatzes stehen |
| #define EscSet ' ' /* Flag setzen */ |
| #define EscReset ' ' /* Flag loeschen */ |
| #define EscDeflt '\x11' /* Flag auf default setzen */ |
| #define EscToggl ' ' /* Flag Toggeln */ |
| #define EscRelat '%' |
| #define EscNoFlg 0 |
| #define EscNoVal -2147483647 /* -MaxLongInt */ |
| //============================================================================== |
| #define NoTrenn 0xFFFF /* Wert fuer Parameter 'Rest' von GetTextChar(), wenn auf keinen Fall getrennt werden soll */ |
| #define DoTrenn 0xFFFE /* Wert fuer Parameter 'Rest' von GetTextChar(), wenn getrennt werden soll */ |
| |
| #define MaxLineChars 1024 |
| |
| #define ChrXPosArrSize (MaxLineChars+1+1) /* 2k - Beginnt mit 0 im gegensatz zu StarDraw */ |
| #define CharLineSize (MaxLineChars+1+1) |
| #define EscStr (UCHAR[MaxEscLen+1]); |
| |
| #define MinChar 32 |
| #define MaxChar 255 |
| |
| |
| //============================================================================== |
| |
| #define DefaultCharWidth 4800 |
| #define GradDiv 2 |
| #define CharTopToBase 100 /* wegen Apostrophe und Umlaute mehr als 75% */ |
| #define CharTopToBtm 120 /* Zeilenhoehe ist groesser als Schriftgrad */ |
| // bei Avanti-Bold 'ue' eigentlich sogar 130% |
| |
| // end of AbsBase.Pas |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| // DefBase.Pas |
| |
| #define TextBoldBit 0x0001 /* Fett */ |
| #define TextRSlnBit 0x0002 /* Kursiv */ |
| #define TextUndlBit 0x0004 /* Unterstrichen */ |
| #define TextStrkBit 0x0008 /* Durchgesteichen */ |
| #define TextSupSBit 0x0010 /* Hocgestellt */ |
| #define TextSubSBit 0x0020 /* Tiefgestellt */ |
| #define TextKaptBit 0x0040 /* Kapitaelchen */ |
| #define TextLSlnBit 0x0080 /* Linkskursiv */ |
| #define TextDbUnBit 0x0100 /* Doppelt unterstrichen */ |
| #define TextDbStBit 0x0200 /* Doppelt durchgestrichen */ |
| #define TextSh2DBit 0x0400 /* 2D-Schatten 2.0 */ |
| #define TextSh3DBit 0x0800 /* 3D-Schatten 2.0 */ |
| #define TextSh4DBit 0x1000 /* 4D-Schatten 2.0 */ |
| #define TextShEbBit 0x2000 /* Embossed-Schatten 2.0 */ |
| #define FontAtrBits (TextBoldBit | TextRSlnBit) |
| |
| #define THJustLeft 0x00 |
| #define THJustCenter 0x01 |
| #define THJustRight 0x02 |
| #define THJustBlock 0x03 |
| #define THJustDrvOut 0x04 /* Austreibend Formatiert */ |
| #define THJustLocked 0x05 /* A l s S p e r r s c h r i f t */ |
| #define TVJustTop 0x00 /* Future */ |
| #define TVJustCenter 0x10 /* Future */ |
| #define TVJustBottom 0x20 /* Future */ |
| #define TVJustBlock 0x30 /* Future */ |
| |
| #define MaxCharSlant 4200 /* Maximal 42deg kursiv ! */ |
| |
| // end of DefBase.Pas |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| |
| sal_Bool CheckTextOutl(ObjAreaType& F, ObjLineType& L); |
| |
| sal_Bool CheckTextOutl(ObjAreaType& F, ObjLineType& L) |
| { |
| return (F.FIntens!=L.LIntens) || |
| ((F.FFarbe!=L.LFarbe) && (F.FIntens>0)) || |
| ((F.FBFarbe!=L.LBFarbe) && (F.FIntens<100)); |
| } |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| // Misc.Pas |
| |
| short hPoint2Sgf(short a) |
| { |
| long b; |
| b=long(a)*127*SgfDpmm/(144*5); |
| return short(b); |
| } |
| |
| short Sgf2hPoint(short a) |
| { |
| long b; |
| b=long(a)*5*144/(127*SgfDpmm); |
| return short(b); |
| } |
| |
| // End of Misc.Pas |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| // AbsRead.Pas |
| |
| // ====================================================================== |
| // Function GetTopToBaseLine() Function GetBaseLineToBtm() |
| // |
| // Abstand von Zeilenoberkante bis BaseLine bzw. von BaseLine bis |
| // Unterkante berechnen. Alles in SGF-Units. |
| // ====================================================================== |
| |
| sal_uInt16 GetTopToBaseLine(sal_uInt16 MaxGrad) |
| { |
| long ret; |
| ret=long(MaxGrad)*long(CharTopToBase) /long(100); |
| return sal_uInt16(ret); |
| } |
| |
| // ====================================================================== |
| // Function GetTextChar() Function GetTextCharConv() |
| // |
| // Liest ein Zeichen aus dem Textbuffer, wertet dabei eventuell |
| // auftretende Escapesequenzen aus und setzt dementsprechend den |
| // Ein-/Ausgabeparameter AktAtr. Index wird entsprechend erhoeht. |
| // Der Parameter Rest muss immer die Anzahl der Zeichen beinhalten, |
| // den angeforderten Zeichen in der aktuellen Zeile noch folgen. |
| // Ansonsten funktioniert die Silbentrennung nicht richtig. Gibt man |
| // stattdessen die Konstante NoTrenn an, wird in keinem Fall |
| // getrennt, die Konstante DoTrenn bewirkt dagegen, dass ueberall dort |
| // getrennt wird, wo ein SoftTrenner vorkommt. |
| // |
| // SoftTrenner werden immer in ein Minuszeichen konvertiert. |
| // GetTextCharConv() konvertiert zusaetzlich HardSpace und AbsatzEnde |
| // in Spaces sowie HardTrenner in Minuszeichen. TextEnde wird immer |
| // als Char(0) geliefert. |
| // ====================================================================== |
| |
| |
| |
| UCHAR ConvertTextChar(UCHAR c) |
| { |
| if (c<32) { |
| switch (c) { |
| case HardSpace : c=' '; break; |
| case AbsatzEnd : c=' '; break; |
| case SoftTrenn : c='-'; break; |
| case HardTrenn : c='-'; break; |
| case SoftTrennK : c='-'; break; |
| case SoftTrennAdd: c='-'; |
| } |
| } |
| return c; |
| } |
| |
| |
| |
| sal_uInt16 GetSchnittBit(UCHAR c) |
| { |
| sal_uInt16 r=0; |
| switch (c) { |
| case EscBold : r=TextBoldBit; break; |
| case EscRSlnt: r=TextRSlnBit; break; |
| case EscUndln: r=TextUndlBit; break; |
| case EscStrik: r=TextStrkBit; break; |
| case EscDbUnd: r=TextDbUnBit; break; |
| case EscDbStk: r=TextDbStBit; break; |
| case EscSupSc: r=TextSupSBit; break; |
| case EscSubSc: r=TextSubSBit; break; |
| case EscKaptF: r=TextKaptBit; break; |
| case EscLSlnt: r=TextLSlnBit; break; |
| case Esc2DShd: r=TextSh2DBit; break; |
| case Esc3DShd: r=TextSh3DBit; break; |
| case Esc4DShd: r=TextSh4DBit; break; |
| case EscEbShd: r=TextShEbBit; |
| } |
| return r; |
| } |
| |
| |
| |
| long ChgValue(long Def, long Min, long Max, UCHAR FlgVal, long NumVal) |
| { |
| long r=0; |
| |
| if (FlgVal==EscDeflt) { |
| r=Def; // zurueck auf Default |
| } else { |
| if (NumVal!=EscNoVal) r=NumVal; // Hart setzen |
| } |
| |
| if (Min!=0 || Max!=0) { |
| if (r>Max) r=Max; |
| if (r<Min) r=Min; |
| } |
| return r; |
| } |
| |
| |
| |
| void ChgSchnittBit(sal_uInt16 Bit, sal_uInt16 Radio1, sal_uInt16 Radio2, sal_uInt16 Radio3, |
| UCHAR FlgVal, sal_uInt16 Schnitt0, sal_uInt16& Schnitt) |
| { |
| sal_uInt16 All,Rad; |
| |
| Rad=Radio1 | Radio2 | Radio3; |
| All=Bit | Rad; |
| |
| switch (FlgVal) { |
| case EscSet : Schnitt=(Schnitt & ~All) | Bit; break; |
| case EscReset: Schnitt=(Schnitt & ~All); break; |
| case EscDeflt: Schnitt=(Schnitt & ~All) | (Schnitt0 & All); break; |
| case EscToggl: Schnitt=(Schnitt & ~Rad) ^ Bit; |
| } |
| } |
| |
| |
| |
| UCHAR GetNextChar(UCHAR* TBuf, sal_uInt16 Index) |
| { |
| sal_uInt16 Cnt; |
| while (TBuf[Index]==Escape) { |
| Index++; |
| Cnt=0; |
| while (TBuf[Index]!=Escape && Cnt<=MaxEscLen) { |
| Index++; Cnt++; } |
| Index++; |
| } |
| return TBuf[Index]; |
| } |
| |
| |
| |
| UCHAR ProcessOne(UCHAR* TBuf, sal_uInt16& Index, |
| ObjTextType& Atr0, ObjTextType& AktAtr, |
| sal_Bool ScanEsc) |
| { |
| UCHAR c; |
| UCHAR Ident; |
| sal_Bool Ende; |
| sal_Bool q; |
| UCHAR FlgVal; |
| long NumVal; |
| long Sgn; |
| short i; |
| sal_Bool EoVal; |
| |
| do { |
| c=TBuf[Index]; Index++; |
| Ende=(c!=Escape); |
| if (Ende==sal_False) { |
| c=TBuf[Index]; Index++; |
| Ident=c; // Identifer merken |
| FlgVal=EscNoFlg; |
| NumVal=EscNoVal; |
| c=TBuf[Index]; Index++; // Hier faengt der Wert an |
| if (c==EscSet || c==EscReset || c==EscDeflt || c==EscToggl) FlgVal=c; else { |
| if (c=='-') Sgn=-1; else Sgn=1; |
| if (c=='+' || c=='-') { c=TBuf[Index]; Index++; } |
| i=MaxEscValLen; |
| NumVal=0; |
| do { |
| NumVal=10*NumVal+c-'0'; |
| EoVal=(TBuf[Index]<'0' || TBuf[Index]>'9'); |
| if (EoVal==sal_False) { c=TBuf[Index]; Index++; } |
| i--; |
| } while (i>0 && EoVal==sal_False); |
| NumVal=Sgn*NumVal; |
| } |
| q=!CheckTextOutl(AktAtr.F,AktAtr.L); |
| |
| switch (Ident) { |
| case EscFont : AktAtr.SetFont(sal_uLong (ChgValue(Atr0.GetFont(),0,0 ,FlgVal,NumVal)));break; |
| case EscGrad : AktAtr.Grad =sal_uInt16(ChgValue(Atr0.Grad, 2,2000 ,FlgVal,NumVal)); break; |
| case EscBreit: AktAtr.Breite =sal_uInt16(ChgValue(Atr0.Breite, 1,1000 ,FlgVal,NumVal)); break; |
| case EscKaptS: AktAtr.Kapit =(sal_uInt8)(ChgValue(Atr0.Kapit, 1,255 ,FlgVal,NumVal)); break; |
| case EscLFeed: AktAtr.LnFeed =sal_uInt16(ChgValue(Atr0.LnFeed, 1,65535 ,FlgVal,NumVal)); break; |
| case EscSlant: AktAtr.Slant =sal_uInt16(ChgValue(Atr0.Slant, 1,MaxCharSlant ,FlgVal,NumVal)); break; |
| case EscVPos : AktAtr.ChrVPos=char (ChgValue(Atr0.ChrVPos,-128,127 ,FlgVal,NumVal)); break; |
| case EscZAbst: AktAtr.ZAbst =(sal_uInt8)(ChgValue(Atr0.ZAbst, 1,255 ,FlgVal,NumVal)); break; |
| case EscHJust: AktAtr.Justify=(sal_uInt8)(ChgValue(Atr0.Justify & 0x0F,0,5 ,FlgVal,NumVal)); break; |
| case EscFarbe: { AktAtr.L.LFarbe =(sal_uInt8)(ChgValue(Atr0.L.LFarbe,0,7 ,FlgVal,NumVal)); if (q) AktAtr.F.FFarbe =AktAtr.L.LFarbe; } break; |
| case EscBFarb: { AktAtr.L.LBFarbe=(sal_uInt8)(ChgValue(Atr0.L.LBFarbe,0,255,FlgVal,NumVal)); if (q) AktAtr.F.FBFarbe=AktAtr.L.LBFarbe; } break; |
| case EscInts : { AktAtr.L.LIntens=(sal_uInt8)(ChgValue(Atr0.L.LIntens,0,100,FlgVal,NumVal)); if (q) AktAtr.F.FIntens=AktAtr.L.LIntens; } break; |
| |
| case EscMustr: { AktAtr.F.FMuster=sal_uInt16(ChgValue(Atr0.F.FMuster,0,65535,FlgVal,NumVal)); } break; |
| case EscMFarb: { AktAtr.F.FFarbe =(sal_uInt8)(ChgValue(Atr0.F.FFarbe,0,7 ,FlgVal,NumVal)); } break; |
| case EscMBFrb: { AktAtr.F.FBFarbe=(sal_uInt8)(ChgValue(Atr0.F.FBFarbe,0,255,FlgVal,NumVal)); } break; |
| case EscMInts: { AktAtr.F.FIntens=(sal_uInt8)(ChgValue(Atr0.F.FIntens,0,100,FlgVal,NumVal)); } break; |
| |
| case EscSMstr: { AktAtr.ShdF.FMuster=sal_uInt16(ChgValue(Atr0.ShdF.FMuster,0,65535,FlgVal,NumVal)); } break; |
| case EscSFarb: { AktAtr.ShdL.LFarbe =(sal_uInt8)(ChgValue(Atr0.ShdL.LFarbe,0,7 ,FlgVal,NumVal)); AktAtr.ShdF.FFarbe =AktAtr.ShdL.LFarbe; } break; |
| case EscSBFrb: { AktAtr.ShdL.LBFarbe=(sal_uInt8)(ChgValue(Atr0.ShdL.LBFarbe,0,255,FlgVal,NumVal)); AktAtr.ShdF.FBFarbe=AktAtr.ShdL.LBFarbe; } break; |
| case EscSInts: { AktAtr.ShdL.LIntens=(sal_uInt8)(ChgValue(Atr0.ShdL.LIntens,0,100,FlgVal,NumVal)); AktAtr.ShdF.FIntens=AktAtr.ShdL.LIntens; } break; |
| case EscSDist: { AktAtr.ShdVers.x=(short)ChgValue(Atr0.ShdVers.x,0,30000,FlgVal,NumVal); AktAtr.ShdVers.y=AktAtr.ShdVers.x; } break; |
| case EscSXDst: { AktAtr.ShdVers.x=(short)ChgValue(Atr0.ShdVers.x,0,30000,FlgVal,NumVal); } break; |
| case EscSYDst: { AktAtr.ShdVers.y=(short)ChgValue(Atr0.ShdVers.y,0,30000,FlgVal,NumVal); } break; |
| |
| case EscBold : ChgSchnittBit(TextBoldBit,0,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case EscRSlnt: ChgSchnittBit(TextRSlnBit,TextLSlnBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case EscUndln: ChgSchnittBit(TextUndlBit,TextDbUnBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case EscStrik: ChgSchnittBit(TextStrkBit,TextDbStBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case EscDbUnd: ChgSchnittBit(TextDbUnBit,TextUndlBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case EscDbStk: ChgSchnittBit(TextDbStBit,TextStrkBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case EscSupSc: ChgSchnittBit(TextSupSBit,TextSubSBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case EscSubSc: ChgSchnittBit(TextSubSBit,TextSupSBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case EscKaptF: ChgSchnittBit(TextKaptBit,0,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case EscLSlnt: ChgSchnittBit(TextLSlnBit,TextRSlnBit,0,0 ,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case Esc2DShd: ChgSchnittBit(TextSh2DBit,TextSh3DBit,TextSh4DBit,TextShEbBit,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case Esc3DShd: ChgSchnittBit(TextSh3DBit,TextSh2DBit,TextSh4DBit,TextShEbBit,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case Esc4DShd: ChgSchnittBit(TextSh4DBit,TextSh2DBit,TextSh3DBit,TextShEbBit,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| case EscEbShd: ChgSchnittBit(TextShEbBit,TextSh2DBit,TextSh3DBit,TextSh4DBit,FlgVal,Atr0.Schnitt,AktAtr.Schnitt); break; |
| } //endcase |
| if (TBuf[Index]==Escape) Index++; // zweites Esc weglesen } |
| } // if Ende==sal_False |
| } while (Ende==sal_False && ScanEsc==sal_False); |
| if (Ende==sal_False) c=Escape; |
| return c; |
| } // end of ProcessOne |
| |
| |
| UCHAR GetTextChar(UCHAR* TBuf, sal_uInt16& Index, |
| ObjTextType& Atr0, ObjTextType& AktAtr, |
| sal_uInt16 Rest, sal_Bool ScanEsc) |
| { |
| UCHAR c,c0,nc; |
| |
| c=ProcessOne(TBuf,Index,Atr0,AktAtr,ScanEsc); |
| if (ScanEsc==sal_False) { |
| if (c==SoftTrennAdd || c==SoftTrennK || c==SoftTrenn) { |
| nc=GetNextChar(TBuf,Index); |
| c0=c; |
| if (Rest==0 || Rest==DoTrenn || |
| nc==' ' || nc==AbsatzEnd || nc==TextEnd) c='-'; |
| else { |
| c=ProcessOne(TBuf,Index,Atr0,AktAtr,ScanEsc); // den Trenner ueberspringen |
| if (c0==SoftTrennAdd) { |
| if (c>=32) c=ProcessOne(TBuf,Index,Atr0,AktAtr,ScanEsc); // und hier noch 'nen Buchstaben ueberspringen |
| } |
| } |
| } |
| if ((Rest==1 || Rest==DoTrenn) && GetNextChar(TBuf,Index)==SoftTrennK) { |
| if (c=='c') c='k'; |
| else if (c=='C') c='K'; |
| } |
| } |
| return c; |
| } |
| |
| // HardSpace und HardTrenn muessen explizit konvertiert werden ! } |
| // if AktAtr.Schnitt and TextKaptBit =TextKaptBit then c:=UpCase(c);(explizit) } |
| |
| // Bei der Trennmethode SoftTrennAdd wird davon ausgegangen, dass der zu } |
| // trennende Konsonant bereits 3x mal im TextBuf vorhanden ist, z.b.: } |
| // "Schiff-fahrt". Wenn nicht getrennt, dann wird "-f" entfernt. } |
| |
| |
| |
| UCHAR GetTextCharConv(UCHAR* TBuf, sal_uInt16& Index, |
| ObjTextType& Atr0, ObjTextType& AktAtr, |
| sal_uInt16 Rest, sal_Bool ScanEsc) |
| { |
| UCHAR c; |
| |
| c=GetTextChar(TBuf,Index,Atr0,AktAtr,Rest,ScanEsc); |
| if (c<32) { |
| switch (c) { |
| case HardSpace : c=' '; break; |
| case AbsatzEnd : c=' '; break; |
| case HardTrenn : c='-'; |
| } |
| } |
| return c; |
| } |
| |
| |
| // ====================================================================== |
| // Function GetLineFeed() |
| // |
| // Benoetigter Zeilenabstand in SGF-Units. ChrVPos wird beruecksichtigt. |
| // ====================================================================== |
| sal_uInt16 GetLineFeed(UCHAR* TBuf, sal_uInt16 Index, ObjTextType Atr0, ObjTextType AktAtr, |
| sal_uInt16 nChar, sal_uInt16& LF, sal_uInt16& MaxGrad) |
| { |
| UCHAR c=0; |
| sal_Bool AbsEnd=sal_False; |
| sal_uLong LF100=0; |
| sal_uLong MaxLF100=0; |
| sal_Bool LFauto=0; |
| sal_Bool First=sal_True; |
| sal_uInt16 Grad; |
| sal_uInt16 i=0; |
| sal_uInt16 r=1; |
| |
| MaxGrad=0; |
| while (!AbsEnd && nChar>0) { |
| nChar--; |
| c=GetTextChar(TBuf,Index,Atr0,AktAtr,nChar,sal_False); |
| i++; |
| AbsEnd=(c==TextEnd || c==AbsatzEnd); |
| if (First || (!AbsEnd && c!=' ' && c!=HardTrenn)) { |
| LFauto=(AktAtr.LnFeed & 0x8000)==0; |
| LF100=AktAtr.LnFeed & 0x7FFF; |
| if (LFauto) LF100=LF100*AktAtr.Grad; else LF100*=LF100; |
| if (AktAtr.ChrVPos>0) LF100-=AktAtr.ChrVPos*100; |
| if (LF100>MaxLF100) MaxLF100=LF100; |
| Grad=AktAtr.Grad; |
| if (AktAtr.ChrVPos>0) Grad=Grad-AktAtr.ChrVPos; |
| if (Grad>MaxGrad) MaxGrad=Grad; |
| First=sal_False; |
| } |
| if (!AbsEnd && c!=' ') r=i; |
| } |
| MaxGrad=hPoint2Sgf(MaxGrad); |
| if (MaxLF100<=4000) { // sonst Overflowgefahr |
| LF=sal_uInt16(hPoint2Sgf(short(MaxLF100)) /100); |
| } else { |
| LF=sal_uInt16(hPoint2Sgf(short(MaxLF100) /100)); |
| } |
| |
| return r; |
| } |
| |
| // End of AbsRead.Pas |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| // iFont.Pas |
| |
| #define DefaultSlant 1500 /* Default: Italic ist 15deg */ |
| #define SuperSubFact 60 /* SuperScript/SubScript: 60% vom Schriftgrad */ |
| #define DefaultSpace 40 /* Default: Space ist 40% vom SchriftGrad */ |
| |
| sal_uInt16 SetTextContext(OutputDevice& rOut, ObjTextType& Atr, sal_Bool Kapt, sal_uInt16 Dreh, |
| sal_uInt16 FitXMul, sal_uInt16 FitXDiv, sal_uInt16 FitYMul, sal_uInt16 FitYDiv) |
| { |
| SgfFontOne* pSgfFont; // Font aus dem IniFile |
| Font aFont; |
| Color aColor; |
| sal_uLong Grad; |
| sal_uLong Brei; |
| String FNam; |
| sal_uInt16 StdBrei=50; // Durchschnittliche Zeichenbreite in % von Schriftgrad |
| sal_Bool bFit=(FitXMul!=1 || FitXDiv!=1 || FitYMul!=1 || FitYDiv!=1); |
| |
| pSgfFont = pSgfFonts->GetFontDesc(Atr.GetFont()); |
| |
| if ( pSgfFont!=NULL ) |
| { |
| FNam =pSgfFont->SVFName; |
| StdBrei=pSgfFont->SVWidth; |
| if (pSgfFont->Fixd) aFont.SetPitch(PITCH_FIXED); else aFont.SetPitch(PITCH_VARIABLE); |
| aFont.SetFamily(pSgfFont->SVFamil); |
| aFont.SetCharSet(pSgfFont->SVChSet); |
| aFont.SetName(FNam); |
| } |
| else |
| { // Falls nich im Inifile, sind hier einige Fonts hart kodiert |
| aFont.SetPitch(PITCH_VARIABLE); |
| switch (Atr.GetFont()) { |
| case 92500: case 92501: case 92504: case 92505: |
| { |
| #if defined(WNT) || defined(OS2) |
| FNam=String::CreateFromAscii( "Times New Roman" ); // CG Times ist unter Windows und OS/2 Times New Roman |
| #else |
| FNam=String::CreateFromAscii( "Times" ); // ansonsten ist das einfach Times |
| #endif |
| StdBrei=40; |
| aFont.SetFamily(FAMILY_ROMAN); |
| } break; |
| case 94021: case 94022: case 94023: case 94024: { |
| #if defined(WNT) |
| FNam=String::CreateFromAscii( "Arial", 5 ); // Univers ist unter Windows Arial |
| #else |
| FNam=String::CreateFromAscii( "Helvetica" ); // und ansonsten Helvetica |
| #endif |
| aFont.SetFamily(FAMILY_SWISS); |
| StdBrei=47; |
| } break; |
| case 93950: case 93951: case 93952: case 93953: { |
| #if defined(WNT) |
| FNam=String::CreateFromAscii( "Courier New" ); // Der Vector-Courierfont unter Windows heisst Courier New |
| #else |
| FNam=String::CreateFromAscii( "Courier" ); // ansonsten ist und bleibt Courier immer Courier |
| #endif |
| aFont.SetFamily(FAMILY_ROMAN); |
| aFont.SetPitch(PITCH_FIXED); |
| } break; |
| default: FNam=String::CreateFromAscii( "Helvetica", 9 ); |
| } |
| aFont.SetName(FNam); |
| //aFont.SetCharSet(CHARSET_SYSTEM); |
| } |
| |
| Grad=sal_uLong(Atr.Grad); |
| if ((Atr.Schnitt & TextKaptBit) !=0 && Kapt) Grad=Grad*sal_uLong(Atr.Kapit)/100; |
| if ((Atr.Schnitt & TextSupSBit) !=0 || (Atr.Schnitt & TextSubSBit) !=0) Grad=Grad*SuperSubFact/100; |
| Brei=Grad; |
| if (Atr.Breite!=100 || bFit) { |
| if (bFit) { |
| Grad=Grad*sal_uLong(FitYMul)/sal_uLong(FitYDiv); |
| Brei=Brei*sal_uLong(FitXMul)/sal_uLong(FitXDiv); |
| } |
| Brei=Brei*sal_uLong(Atr.Breite)/100; |
| Brei=Brei*sal_uLong(StdBrei)/100; |
| aFont.SetSize(Size(hPoint2Sgf(sal_uInt16(Brei)),hPoint2Sgf(sal_uInt16(Grad)))); |
| } else { |
| aFont.SetSize(Size(0,hPoint2Sgf(sal_uInt16(Grad)))); |
| } |
| |
| aColor=Sgv2SvFarbe(Atr.L.LFarbe,Atr.L.LBFarbe,Atr.L.LIntens); aFont.SetColor(aColor); |
| aColor=Sgv2SvFarbe(Atr.F.FFarbe,Atr.F.FBFarbe,Atr.F.FIntens); aFont.SetFillColor(aColor); |
| aFont.SetTransparent(sal_True); |
| aFont.SetAlign(ALIGN_BASELINE); |
| |
| Dreh/=10; Dreh=3600-Dreh; if (Dreh==3600) Dreh=0; |
| aFont.SetOrientation(Dreh); |
| |
| if ((Atr.Schnitt & TextBoldBit) !=0) aFont.SetWeight(WEIGHT_BOLD); |
| if ((Atr.Schnitt & TextRSlnBit) !=0) aFont.SetItalic(ITALIC_NORMAL); |
| if ((Atr.Schnitt & TextUndlBit) !=0) aFont.SetUnderline(UNDERLINE_SINGLE); |
| if ((Atr.Schnitt & TextDbUnBit) !=0) aFont.SetUnderline(UNDERLINE_DOUBLE); |
| if ((Atr.Schnitt & TextStrkBit) !=0) aFont.SetStrikeout(STRIKEOUT_SINGLE); |
| if ((Atr.Schnitt & TextDbStBit) !=0) aFont.SetStrikeout(STRIKEOUT_DOUBLE); |
| if ((Atr.Schnitt & TextSh2DBit) !=0) aFont.SetShadow(sal_True); |
| if ((Atr.Schnitt & TextSh3DBit) !=0) aFont.SetShadow(sal_True); |
| if ((Atr.Schnitt & TextSh4DBit) !=0) aFont.SetShadow(sal_True); |
| if ((Atr.Schnitt & TextShEbBit) !=0) aFont.SetShadow(sal_True); |
| if (CheckTextOutl(Atr.F,Atr.L)) aFont.SetOutline(sal_True); |
| |
| if (aFont!=rOut.GetFont()) rOut.SetFont(aFont); |
| |
| return 0; |
| } |
| |
| // iFont.Pas |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| // Absatz.Pas |
| |
| struct ProcChrSta { |
| sal_uInt16 Index; |
| sal_uInt16 ChrXP; |
| UCHAR OutCh; |
| sal_Bool Kapt; |
| ObjTextType Attrib; |
| }; |
| |
| void InitProcessCharState(ProcChrSta& State, ObjTextType& AktAtr, sal_uInt16 IndexA) |
| { |
| State.Attrib=AktAtr; |
| State.OutCh=0; |
| State.Index=IndexA; |
| State.ChrXP=0; |
| State.Kapt=sal_False; |
| } |
| |
| sal_Bool UpcasePossible(UCHAR c) |
| { |
| if ((c>='a' && c<='z') || c == 0xe4 || c == 0xf6 || c == 0xfc ) return sal_True; |
| else return sal_False; |
| } |
| |
| UCHAR Upcase(UCHAR c) |
| { |
| if ((c>=(UCHAR)'a' && c<=(UCHAR)'z')) c=(c-(UCHAR)'a')+(UCHAR)'A'; |
| else if ( c == 0xe4 ) c = 0xc4; |
| else if ( c == 0xf6 ) c = 0xd6; |
| else if ( c == 0xfc ) c = 0xdc; |
| return c; |
| } |
| |
| sal_uInt16 GetCharWidth(OutputDevice& rOut, UCHAR c) |
| { |
| UCHAR c1; |
| sal_uInt16 ChrWidth; |
| |
| c1 = ByteString::Convert((char)c,RTL_TEXTENCODING_IBM_437, gsl_getSystemTextEncoding() ); |
| if (c==' ') |
| { |
| ChrWidth=(sal_uInt16)rOut.GetTextWidth( String('A') ); |
| if (rOut.GetFont().GetPitch()!=PITCH_FIXED) { |
| ChrWidth=MulDiv(ChrWidth,DefaultSpace,100); |
| } |
| } else { |
| // with MaxChar == 255 c cannot be greater than MaxChar |
| // assert if MaxChar is ever changed |
| OSL_ENSURE( MaxChar == 255, "MaxChar not 255" ); |
| if (c>=MinChar /*&& c<=MaxChar*/) |
| { |
| ChrWidth=(sal_uInt16)rOut.GetTextWidth(String((char)c1)); |
| } |
| else |
| { |
| ChrWidth=(sal_uInt16)rOut.GetTextWidth(String('A')); |
| } |
| } |
| return ChrWidth; |
| } |
| |
| UCHAR ProcessChar(OutputDevice& rOut, UCHAR* TBuf, ProcChrSta& R, ObjTextType& Atr0, |
| sal_uInt16& nChars, sal_uInt16 Rest, |
| short* Line, UCHAR* cLine) |
| { |
| sal_uInt16 KernDist=0; // Wert fuer Kerning |
| sal_uInt16 ChrWidth; |
| UCHAR c; |
| UCHAR c1; |
| sal_Bool AbsEnd; |
| |
| c=GetTextChar(TBuf,R.Index,Atr0,R.Attrib,Rest,sal_False); // versucht evtl. zu trennen, wenn Rest entsprechenden Wert besitzt |
| |
| AbsEnd=(c==AbsatzEnd || c==TextEnd); |
| if (AbsEnd==sal_False) { |
| R.OutCh=ConvertTextChar(c); // von HardTrenn nach '-', ... |
| R.Kapt=(R.Attrib.Schnitt & TextKaptBit) !=0 && UpcasePossible(R.OutCh); |
| if (R.Kapt) R.OutCh=Upcase(R.OutCh); |
| SetTextContext(rOut,R.Attrib,R.Kapt,0,1,1,1,1); |
| |
| if (R.Kapt) c1=Upcase(c); else c1=c; |
| ChrWidth=GetCharWidth(rOut,c1); |
| |
| if (R.Attrib.ZAbst!=100) { // Spezial-Zeichenabstand ? |
| sal_uLong Temp; |
| Temp=sal_uLong(ChrWidth)*sal_uLong(R.Attrib.ZAbst)/100; |
| ChrWidth=sal_uInt16(Temp); |
| } |
| nChars++; |
| if (R.ChrXP>32000) R.ChrXP=32000; |
| Line[nChars]=R.ChrXP-KernDist; |
| cLine[nChars]=c; |
| R.ChrXP+=ChrWidth-KernDist; // Position fuer den naechsten Character |
| } |
| return c; |
| } |
| |
| void 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) |
| { |
| VirtualDevice vOut; |
| UCHAR c,c0; |
| UCHAR ct; |
| sal_Bool First; // erster Char ? |
| sal_uInt8 Just = 0; // Absatzformatierung |
| sal_Bool Border; // Rand der Box erreicht ? |
| sal_Bool Border0; |
| sal_Bool AbsEnd; // Ende des Absatzes erreicht ? |
| ProcChrSta* R=new ProcChrSta; |
| ProcChrSta* R0=new ProcChrSta; |
| ProcChrSta* WErec=new ProcChrSta; |
| sal_uInt16 WEnChar; |
| ProcChrSta* WErec0=new ProcChrSta; |
| sal_uInt16 WEnChar0; |
| ProcChrSta* TRrec=new ProcChrSta; |
| sal_uInt16 TRnChar; |
| |
| sal_uInt16 WordEndCnt; // Justieren und Trennen |
| sal_Bool WordEnd; |
| sal_Bool Trenn; |
| |
| short BoxRest; // zum Quetschen und formatieren |
| sal_uInt16 i,j,k,h; |
| sal_uInt16 re,li; |
| |
| vOut.SetMapMode(MapMode(MAP_10TH_MM,Point(),Fraction(1,4),Fraction(1,4))); |
| |
| nChars=0; |
| SetTextContext(vOut,AktAtr,sal_False,0,1,1,1,1); |
| InitProcessCharState(*R,AktAtr,Index); |
| (*R0)=(*R); (*WErec)=(*R); WEnChar=0; c0=0; Border0=sal_False; |
| Border=sal_False; First=sal_True; |
| WordEndCnt=0; |
| |
| do { // mal schauen, wieviele Worte so in die Zeile passen |
| if (Border) c=ProcessChar(vOut,TBuf,*R,Atr0,nChars,DoTrenn,Line,cLine); |
| else c=ProcessChar(vOut,TBuf,*R,Atr0,nChars,NoTrenn,Line,cLine); |
| AbsEnd=(c==AbsatzEnd || c==TextEnd); |
| //if not AbsEnd then |
| { |
| if (First) { |
| Just=R->Attrib.Justify & 0x0F; // Absatzformat steht wenn, dann am Anfang |
| } |
| Border=R->ChrXP>UmbWdt; |
| WordEnd=(AbsEnd || (c==' ')) && (c0!=' ') && (c0!=0); |
| Trenn=c=='-'; |
| if (WordEnd && !Border0) { |
| WordEndCnt++; |
| (*WErec)=(*R0); |
| WEnChar=nChars-1; |
| } |
| if (Trenn && !Border) { |
| WordEndCnt++; |
| (*WErec)=(*R); |
| WEnChar=nChars; |
| } |
| } |
| (*R0)=(*R); c0=c; |
| Border0=Border; |
| First=sal_False; |
| AbsEnd=AbsEnd || (nChars>=MaxLineChars); |
| } while (!(AbsEnd || (Border && ((WordEndCnt>0) || WordEnd || Trenn)))); |
| |
| if (Border) { // Trennen und Quetschen |
| (*WErec0)=(*WErec); WEnChar0=WEnChar; |
| AbsEnd=sal_False; c0=0; |
| (*R)=(*WErec); nChars=WEnChar; |
| (*TRrec)=(*R); TRnChar=nChars; |
| Border0=sal_False; Border=sal_False; |
| do { // erst mal gucken wieviele Silben noch reinpassen |
| ct=ProcessChar(vOut,TBuf,*TRrec,Atr0,TRnChar,DoTrenn,Line,cLine); |
| c=ProcessChar(vOut,TBuf,*R,Atr0,nChars,NoTrenn,Line,cLine); |
| AbsEnd=(ct==AbsatzEnd) || (ct==TextEnd) || (nChars>=MaxLineChars); |
| |
| Border=TRrec->ChrXP>UmbWdt; |
| WordEnd=AbsEnd || ((AbsEnd || (c==' ')) && (c0!=' ') && (c0!=0)); |
| Trenn=ct=='-'; |
| if (WordEnd && (!Border0 || (WordEndCnt==0))) { |
| WordEndCnt++; |
| (*WErec)=(*R0); |
| if (AbsEnd) WEnChar=nChars; else WEnChar=nChars-1; |
| (*TRrec)=(*R); TRnChar=nChars; // zum weitersuchen |
| } |
| if (Trenn && (!Border || (WordEndCnt==0))) { |
| WordEndCnt++; // merken, dass man hier trennen kann |
| (*WErec)=(*TRrec); |
| WEnChar=TRnChar; |
| (*TRrec)=(*R); TRnChar=nChars; // zum weitersuchen |
| } |
| (*R0)=(*R); c0=c; |
| Border0=Border; |
| Border=R->ChrXP>UmbWdt; |
| } while (!(AbsEnd || (Border && ((WordEndCnt>0) || WordEnd || Trenn)))); |
| |
| while (WErec0->Index<WErec->Index) { // damit Line[] auch garantiert stimmt } |
| c=ProcessChar(vOut,TBuf,*WErec0,Atr0,WEnChar0,WEnChar-WEnChar0-1,Line,cLine); |
| } |
| |
| (*R)=(*WErec); nChars=WEnChar; |
| |
| if (UmbWdt>=R->ChrXP) { |
| BoxRest=UmbWdt-R->ChrXP; |
| } else { // Zusammenquetschen |
| BoxRest=R->ChrXP-UmbWdt; // um soviel muss gequetscht werden |
| for (i=2;i<=nChars;i++) { // 1. CharPosition bleibt ! |
| Line[i]-=(i-1)*(BoxRest) /(nChars-1); |
| } |
| R->ChrXP=UmbWdt; |
| Line[nChars+1]=UmbWdt; |
| } |
| } |
| |
| if (!AbsEnd) { |
| do { // Leerzeichen weglesen |
| (*WErec)=(*R); |
| c=GetTextChar(TBuf,R->Index,Atr0,R->Attrib,NoTrenn,sal_False); |
| nChars++; |
| Line[nChars]=R->ChrXP; |
| cLine[nChars]=c; |
| } while (c==' '); |
| if (c!=' ' && c!=AbsatzEnd && c!=TextEnd) { |
| nChars--; |
| (*R)=(*WErec); |
| } |
| } |
| |
| if (AbsEnd && nChars<MaxLineChars) { // Ausrichten, statt Blocksatz aber linksbuendig |
| if (Just==3) Just=0; |
| nChars++; Line[nChars]=R->ChrXP; // Damit AbsatzEnde auch weggelesen wird |
| Line[nChars+1]=R->ChrXP; // denn die Breite von CR oder #0 ist nun mal sehr klein |
| if (TBuf[R->Index-1]!=AbsatzEnd && TBuf[R->Index-1]!=TextEnd) { |
| c=GetTextChar(TBuf,R->Index,Atr0,R->Attrib,NoTrenn,sal_False); // Kleine Korrektur. Notig, wenn nur 1 Wort in |
| } |
| } |
| |
| BoxRest=AdjWdt-R->ChrXP; |
| if (TextFit) Just=THJustLeft; |
| |
| switch (Just) { |
| case THJustLeft: break; // Links |
| case THJustCenter: { |
| BoxRest=BoxRest /2; // Mitte |
| for (i=1;i<=nChars;i++) Line[i]=Line[i]+BoxRest; |
| } break; |
| case THJustRight: { // Rechts |
| for (i=1;i<=nChars;i++) Line[i]=Line[i]+BoxRest; |
| } break; |
| case THJustDrvOut: |
| case THJustBlock: { // Block und Austreibend |
| re=nChars; |
| if (Just==THJustDrvOut) re--; |
| while (re>=1 && (cLine[re]==' ' || cLine[re]==TextEnd || cLine[re]==AbsatzEnd)) re--; |
| li=1; |
| while (li<=re && (cLine[li]==' ' || cLine[li]==TextEnd || cLine[li]==AbsatzEnd)) li++; |
| if (Just==THJustDrvOut) BoxRest=AdjWdt-Line[re+1]; |
| |
| j=0; // Anzahl der Spaces ermitteln |
| for (i=li;i<=re;i++) { |
| if (cLine[i]==' ') { |
| j++; |
| } |
| } |
| |
| if (j==0) { // nur 1 Wort ? -> Strecken ! |
| for (i=li+1;i<=re;i++) { // von links nach rechts |
| Line[i]=Line[i]+MulDiv(i-li,BoxRest,re-li+1-1); |
| } |
| } else { |
| k=0; h=0; |
| for (i=li;i<=re;i++) { // j Spaces aufbohren ! |
| if (cLine[i]==' ') { // Space gefunden ! |
| k++; |
| h=MulDiv(k,BoxRest,j); |
| } |
| Line[i]=Line[i]+h; |
| } |
| } |
| for (i=re+1;i<=nChars;i++) Line[i]=Line[i]+BoxRest; // und den Rest anpassen |
| Line[nChars+1]=AdjWdt; |
| } break; |
| case THJustLocked: { //Gesperrt |
| re=nChars-1; |
| while (re>=1 && (cLine[re]==' ' || cLine[re]==TextEnd || cLine[re]==AbsatzEnd)) re--; |
| li=1; |
| while (li<=re && (cLine[li]==' ' || cLine[li]==TextEnd || cLine[li]==AbsatzEnd)) li++; |
| BoxRest=AdjWdt-Line[re+1]; |
| for (i=li+1;i<=re;i++) { // Strecken von links nach rechts |
| Line[i]=Line[i]+MulDiv(i-li,BoxRest,re-li+1-1); |
| } |
| for (i=re+1;i<=nChars;i++) Line[i]=Line[i]+BoxRest; // und den Rest anpassen |
| Line[nChars+1]=AdjWdt; |
| } break; |
| } |
| Index=R->Index; |
| AktAtr=R->Attrib; |
| delete R; |
| delete R0; |
| delete WErec; |
| delete WErec0; |
| delete TRrec; |
| } |
| |
| |
| |
| // End of Absatz.Pas |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| // DrawText.Pas |
| |
| void DrawChar(OutputDevice& rOut, UCHAR c, ObjTextType T, PointType Pos, sal_uInt16 DrehWink, |
| sal_uInt16 FitXMul, sal_uInt16 FitXDiv, sal_uInt16 FitYMul, sal_uInt16 FitYDiv) |
| { |
| SetTextContext(rOut,T,UpcasePossible(c),DrehWink,FitXMul,FitXDiv,FitYMul,FitYDiv); |
| if ((T.Schnitt & TextKaptBit)!=0 && UpcasePossible(c)) c=Upcase(c); |
| String s( (char)c, RTL_TEXTENCODING_IBM_437 ); |
| rOut.DrawText( Point( Pos.x, Pos.y ), s ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* TextType::Draw() |
| |* |
| |* Beschreibung |
| |* Ersterstellung JOE 09.08.93 |
| |* Letzte Aenderung JOE 09.08.93 |
| |* |
| *************************************************************************/ |
| void TextType::Draw(OutputDevice& rOut) |
| { |
| if ((Flags & TextOutlBit)!=0) return; // Sourcetext fuer Outliner !! |
| |
| ObjTextType T1,T2; |
| sal_uInt16 Index1; |
| sal_uInt16 Index2; |
| UCHAR c = TextEnd; |
| sal_uInt16 l; // Anzahl der Zeichen in der Zeile |
| sal_uInt16 i; |
| short yPos0; |
| short xPos; |
| short yPos; |
| sal_uInt16 LF; |
| sal_uInt16 MaxGrad; |
| short xSize; |
| short xSAdj; |
| short ySize; |
| double sn,cs; |
| sal_uInt16 TopToBase; |
| sal_Bool Ende = 0; |
| sal_uInt16 lc; |
| sal_Bool LineFit; // FitSize.x=0? oder Flags -> jede Zeile stretchen |
| sal_Bool TextFit; |
| short* xLine; |
| UCHAR* cLine; // Buffer fuer FormatLine |
| sal_uInt16 FitXMul; |
| sal_uInt16 FitXDiv; |
| sal_uInt16 FitYMul; |
| sal_uInt16 FitYDiv; |
| sal_Bool Fehler; |
| UCHAR* Buf=Buffer; // Zeiger auf die Buchstaben |
| |
| pSgfFonts->ReadList(); |
| xLine=new short[ChrXPosArrSize]; |
| cLine=new UCHAR[CharLineSize]; |
| |
| TextFit=(Flags & TextFitBits)!=0; |
| LineFit=sal_False; |
| LineFit=((Flags & TextFitZBit)!=0); |
| if (TextFit && FitSize.x==0) LineFit=sal_True; |
| |
| if (DrehWink==0) { |
| sn=0.0; |
| cs=1.0; |
| } else { |
| sn=sin(double(DrehWink)*3.14159265359/18000); |
| cs=cos(double(DrehWink)*3.14159265359/18000); |
| } |
| |
| T1=T; Index1=0; yPos=0; xPos=0; |
| if (TextFit) { |
| ySize=Pos2.y-Pos1.y; |
| xSize=32000 /2; // Umbruch |
| xSAdj=Pos2.x-Pos1.x; // zum Ausrichten bei Zentriert/Blocksatz |
| //if (xSize<=0) { xSize=32000 /2; LineFit=sal_True; } |
| FitXMul=sal::static_int_cast< sal_uInt16 >(abs(Pos2.x-Pos1.x)); FitXDiv=FitSize.x; if (FitXDiv==0) FitXDiv=1; |
| FitYMul=sal::static_int_cast< sal_uInt16 >(abs(Pos2.y-Pos1.y)); FitYDiv=FitSize.y; if (FitYDiv==0) FitYDiv=1; |
| } else { |
| xSize=Pos2.x-Pos1.x; |
| xSAdj=xSize; |
| ySize=Pos2.y-Pos1.y; |
| FitXMul=1; FitXDiv=1; |
| FitYMul=1; FitYDiv=1; |
| } |
| if (xSize<0) xSize=0; |
| if (xSAdj<0) xSAdj=0; |
| |
| do { |
| T2=T1; Index2=Index1; |
| FormatLine(Buf,Index2,T,T2,xSize,xSAdj,xLine,l,sn,cs,cLine,LineFit); |
| Fehler=(Index2==Index1); |
| if (!Fehler) { |
| lc=GetLineFeed(Buf,Index1,T,T1,l,LF,MaxGrad); |
| if (TextFit) { |
| if (LineFit) FitXDiv=xLine[lc+1]; |
| if (FitXDiv>0) { |
| long Temp; |
| for (i=1;i<=l+1;i++) { |
| Temp=long(xLine[i])*long(FitXMul) /long(FitXDiv); |
| xLine[i]=short(Temp); |
| } |
| LF=MulDiv(LF,FitYMul,FitYDiv); |
| MaxGrad=MulDiv(MaxGrad,FitYMul,FitYDiv); |
| } else { |
| FitXDiv=1; // 0 gibts nicht |
| } |
| } |
| yPos0=yPos; |
| TopToBase=GetTopToBaseLine(MaxGrad); |
| yPos=yPos+TopToBase; |
| Ende=(yPos0+short(MulDiv(MaxGrad,CharTopToBtm,100))>ySize) && !TextFit; |
| if (!Ende) { |
| T2=T1; Index2=Index1; |
| i=1; |
| while (i<=l) { |
| c=GetTextCharConv(Buf,Index2,T,T2,l-i,sal_False); |
| long xp1,yp1; // wegen Overflowgefahr |
| PointType Pos; |
| xp1=long(Pos1.x)+xPos+long(xLine[i]); |
| yp1=long(Pos1.y)+yPos; |
| if (xp1>32000) xp1=32000; if (xp1<-12000) xp1=-12000; |
| if (yp1>32000) yp1=32000; if (yp1<-12000) yp1=-12000; |
| Pos.x=short(xp1); |
| Pos.y=short(yp1); |
| |
| if (DrehWink!=0) RotatePoint(Pos,Pos1.x,Pos1.y,sn,cs); |
| DrawChar(rOut,c,T2,Pos,DrehWink,FitXMul,FitXDiv,FitYMul,FitYDiv); |
| i++; |
| } // while i<=l |
| yPos=yPos0+LF; |
| T1=T2; Index1=Index2; // Fuer die naechste Zeile |
| } // if ObjMin.y+yPos<=Obj_Max.y |
| } // if !Fehler |
| } while (c!=TextEnd && !Ende && !Fehler); |
| delete[] cLine; |
| delete[] xLine; |
| } |
| |
| // End of DrawText.Pas |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| // nicht mehr benoetigt, da der Pointer nun extra gefuehrt wird |
| // (DEC Alpha hat naemlich 64Bit-Pointer!) |
| //UCHAR* TextType::GetBufPtr() |
| //{ |
| // sal_uLong Temp; |
| // Temp=sal_uLong(BufLo)+0x00010000*sal_uLong(BufHi); |
| // return (UCHAR*)Temp; |
| //} |
| // |
| //void TextType::SetBufPtr(UCHAR* Ptr) |
| //{ |
| // sal_uLong Temp=(sal_uLong)Ptr; |
| // BufLo=sal_uInt16(Temp & 0x0000FFFF); |
| // BufHi=sal_uInt16((Temp & 0xFFFF0000)>>16); |
| //} |
| |
| sal_uInt32 ObjTextType::GetFont() |
| { |
| return sal_uLong(FontLo)+0x00010000*sal_uLong(FontHi); |
| } |
| |
| void ObjTextType::SetFont(sal_uInt32 FontID) |
| { |
| FontLo=sal_uInt16(FontID & 0x0000FFFF); |
| FontHi=sal_uInt16((FontID & 0xFFFF0000)>>16); |
| } |
| |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| // SGF.Ini lesen //////////////////////////////////////////////////////////////// |
| ///////////////////////////////////////////////////////////////////////////////// |
| SgfFontOne::SgfFontOne() |
| { |
| Next=NULL; |
| IFID=0; |
| Bold=sal_False; |
| Ital=sal_False; |
| Sans=sal_False; |
| Serf=sal_False; |
| Fixd=sal_False; |
| SVFamil=FAMILY_DONTKNOW; |
| SVChSet=RTL_TEXTENCODING_DONTKNOW; |
| SVWidth=40; |
| } |
| |
| void SgfFontOne::ReadOne( ByteString& ID, ByteString& Dsc ) |
| { |
| sal_uInt16 i,j,n; |
| ByteString s; |
| |
| if ( Dsc.Len() < 4 || ( Dsc.GetChar( 0 ) != '(' ) ) |
| return; |
| i=1; // Erster Buchstabe des IF-Fontnamen. Davor ist eine '(' |
| while ( i < Dsc.Len() && ( Dsc.GetChar( i ) !=')' ) ) |
| i++; |
| Dsc.Erase(0,i+1); // IF-Fontname loeschen inkl. () |
| |
| if ( Dsc.Len() < 2 || ( Dsc.GetChar( Dsc.Len() - 1 ) !=')' ) ) |
| return; |
| i=Dsc.Len()-2; // hier ist die ')' des SV-Fontnames |
| j=0; |
| while ( i > 0 && ( Dsc.GetChar( i ) != '(' ) ) |
| { |
| i--; |
| j++; |
| } |
| SVFName=String(Dsc,i+1,j); // SV-Fontname rausholen |
| Dsc.Erase(i,j); |
| |
| IFID = (sal_uInt32)ID.ToInt32(); |
| n=Dsc.GetTokenCount(' '); |
| for (i=0;i<n;i++) |
| { |
| s = Dsc.GetToken( i,' ' ); |
| if ( s.Len() ) |
| { |
| s.ToUpperAscii(); |
| if ( s.CompareTo( "BOLD", 4 ) == COMPARE_EQUAL ) Bold=sal_True; |
| else if ( s.CompareTo( "ITAL", 4 ) == COMPARE_EQUAL ) Ital=sal_True; |
| else if ( s.CompareTo( "SERF", 4 ) == COMPARE_EQUAL ) Serf=sal_True; |
| else if ( s.CompareTo( "SANS", 4 ) == COMPARE_EQUAL ) Sans=sal_True; |
| else if ( s.CompareTo( "FIXD", 4 ) == COMPARE_EQUAL ) Fixd=sal_True; |
| else if ( s.CompareTo( "ROMAN", 5 ) == COMPARE_EQUAL ) SVFamil=FAMILY_ROMAN; |
| else if ( s.CompareTo( "SWISS", 5 ) == COMPARE_EQUAL ) SVFamil=FAMILY_SWISS; |
| else if ( s.CompareTo( "MODERN", 6 ) == COMPARE_EQUAL ) SVFamil=FAMILY_MODERN; |
| else if ( s.CompareTo( "SCRIPT", 6 ) == COMPARE_EQUAL ) SVFamil=FAMILY_SCRIPT; |
| else if ( s.CompareTo( "DECORA", 6 ) == COMPARE_EQUAL ) SVFamil=FAMILY_DECORATIVE; |
| else if ( s.CompareTo( "ANSI", 4 ) == COMPARE_EQUAL ) SVChSet=RTL_TEXTENCODING_MS_1252; |
| else if ( s.CompareTo( "IBMPC", 5 ) == COMPARE_EQUAL ) SVChSet=RTL_TEXTENCODING_IBM_850; |
| else if ( s.CompareTo( "MAC", 3 ) == COMPARE_EQUAL ) SVChSet=RTL_TEXTENCODING_APPLE_ROMAN; |
| else if ( s.CompareTo( "SYMBOL", 6 ) == COMPARE_EQUAL ) SVChSet=RTL_TEXTENCODING_SYMBOL; |
| else if ( s.CompareTo( "SYSTEM", 6 ) == COMPARE_EQUAL ) SVChSet = gsl_getSystemTextEncoding(); |
| else if ( s.IsNumericAscii() ) SVWidth=sal::static_int_cast< sal_uInt16 >(s.ToInt32()); |
| } |
| } |
| } |
| |
| ///////////////////////////////////////////////////////////////////////////////// |
| |
| SgfFontLst::SgfFontLst() |
| { |
| pList=NULL; |
| Last=NULL; |
| LastID=0; |
| LastLn=NULL; |
| Tried=sal_False; |
| } |
| |
| SgfFontLst::~SgfFontLst() |
| { |
| RausList(); |
| } |
| |
| void SgfFontLst::RausList() |
| { |
| SgfFontOne* P; |
| SgfFontOne* P1; |
| P=pList; |
| while (P!=NULL) { |
| P1=P->Next; |
| delete P; |
| P=P1; |
| } |
| pList=NULL; |
| Last=NULL; |
| Tried=sal_False; |
| LastID=0; |
| LastLn=NULL; |
| } |
| |
| void SgfFontLst::AssignFN(const String& rFName) |
| { FNam=rFName; } |
| |
| void SgfFontLst::ReadList() |
| { |
| if (!Tried) { |
| Tried=sal_True; |
| LastID=0; |
| LastLn=NULL; |
| SgfFontOne* P,P1; |
| Config aCfg(FNam); |
| aCfg.SetGroup("SGV Fonts fuer StarView"); |
| sal_uInt16 Anz=aCfg.GetKeyCount(); |
| sal_uInt16 i; |
| ByteString FID,Dsc; |
| |
| for (i=0;i<Anz;i++) |
| { |
| FID = aCfg.GetKeyName( i ); |
| FID = FID.EraseAllChars(); // Leerzeichen weg |
| Dsc = aCfg.ReadKey( i ); |
| if ( FID.IsNumericAscii() ) |
| { |
| P=new SgfFontOne; // neuer Eintrag |
| if (Last!=NULL) Last->Next=P; else pList=P; Last=P; // einklinken |
| P->ReadOne(FID,Dsc); // und Zeile interpretieren |
| } |
| } |
| } |
| } |
| |
| SgfFontOne* SgfFontLst::GetFontDesc(sal_uInt32 ID) |
| { |
| if (ID!=LastID) { |
| SgfFontOne* P; |
| P=pList; |
| while (P!=NULL && P->IFID!=ID) P=P->Next; |
| LastID=ID; |
| LastLn=P; |
| } |
| return LastLn; |
| } |
