PageRenderTime 61ms CodeModel.GetById 16ms RepoModel.GetById 0ms app.codeStats 0ms

/libreoffice-3.6.0.2/binfilter/bf_svtools/source/filter.vcl/filter/svt_sgvmain.cxx

#
C++ | 1089 lines | 798 code | 74 blank | 217 comment | 111 complexity | d8fe0e6235882d37513329483865cb4e MD5 | raw file
Possible License(s): MPL-2.0-no-copyleft-exception, LGPL-2.1, AGPL-1.0, BSD-3-Clause-No-Nuclear-License-2014, GPL-3.0, LGPL-3.0 
    

  1. /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    2. 

  2. /*************************************************************************
    3. 

  3.  *
    4. 

  4.  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
    5. 

  5.  *
    6. 

  6.  * Copyright 2000, 2010 Oracle and/or its affiliates.
    7. 

  7.  *
    8. 

  8.  * OpenOffice.org - a multi-platform office productivity suite
    9. 

  9.  *
    10. 

  10.  * This file is part of OpenOffice.org.
    11. 

  11.  *
    12. 

  12.  * OpenOffice.org is free software: you can redistribute it and/or modify
    13. 

  13.  * it under the terms of the GNU Lesser General Public License version 3
    14. 

  14.  * only, as published by the Free Software Foundation.
    15. 

  15.  *
    16. 

  16.  * OpenOffice.org is distributed in the hope that it will be useful,
    17. 

  17.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    18. 

  18.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    19. 

  19.  * GNU Lesser General Public License version 3 for more details
    20. 

  20.  * (a copy is included in the LICENSE file that accompanied this code).
    21. 

  21.  *
    22. 

  22.  * You should have received a copy of the GNU Lesser General Public License
    23. 

  23.  * version 3 along with OpenOffice.org.  If not, see
    24. 

  24.  * <http://www.openoffice.org/license.html>
    25. 

  25.  * for a copy of the LGPLv3 License.
    26. 

  26.  *
    27. 

  27.  ************************************************************************/
    28. 

  28. 

  29. #include <osl/endian.h>
    30. 

  30. #include <vcl/graph.hxx>
    31. 

  31. #include <tools/poly.hxx>
    32. 

  32. #include <bf_svtools/filter.hxx>
    33. 

  33. #include "sgffilt.hxx"
    34. 

  34. #include "sgfbram.hxx"
    35. 

  35. #include "sgvmain.hxx"
    36. 

  36. #include "sgvspln.hxx"
    37. 

  37. #include <unotools/ucbstreamhelper.hxx>
    38. 

  38. 

  39. namespace binfilter
    40. 

  40. {
    41. 

  41. 

  42. #define SWAPPOINT(p) {  \
    43. 

  43.     p.x=SWAPSHORT(p.x); \
    44. 

  44.     p.y=SWAPSHORT(p.y); }
    45. 

  45. 

  46. #define SWAPPAGE(p) {                         \
    47. 

  47.     p.Next   =SWAPLONG (p.Next   );           \
    48. 

  48.     p.nList  =SWAPLONG (p.nList  );           \
    49. 

  49.     p.ListEnd=SWAPLONG (p.ListEnd);           \
    50. 

  50.     p.Paper.Size.x=SWAPSHORT(p.Paper.Size.x); \
    51. 

  51.     p.Paper.Size.y=SWAPSHORT(p.Paper.Size.y); \
    52. 

  52.     p.Paper.RandL =SWAPSHORT(p.Paper.RandL ); \
    53. 

  53.     p.Paper.RandR =SWAPSHORT(p.Paper.RandR ); \
    54. 

  54.     p.Paper.RandO =SWAPSHORT(p.Paper.RandO ); \
    55. 

  55.     p.Paper.RandU =SWAPSHORT(p.Paper.RandU ); \
    56. 

  56.     SWAPPOINT(p.U);                           \
    57. 

  57.     UINT16 iTemp;                             \
    58. 

  58.     for (iTemp=0;iTemp<20;iTemp++) {          \
    59. 

  59.         rPage.HlpLnH[iTemp]=SWAPSHORT(rPage.HlpLnH[iTemp]);       \
    60. 

  60.         rPage.HlpLnV[iTemp]=SWAPSHORT(rPage.HlpLnV[iTemp]);      }}
    61. 

  61. 

  62. #define SWAPOBJK(o) {                 \
    63. 

  63.     o.Last    =SWAPLONG (o.Last    ); \
    64. 

  64.     o.Next    =SWAPLONG (o.Next    ); \
    65. 

  65.     o.MemSize =SWAPSHORT(o.MemSize ); \
    66. 

  66.     SWAPPOINT(o.ObjMin);              \
    67. 

  67.     SWAPPOINT(o.ObjMax);              }
    68. 

  68. 

  69. #define SWAPLINE(l) {             \
    70. 

  70.     l.LMSize=SWAPSHORT(l.LMSize); \
    71. 

  71.     l.LDicke=SWAPSHORT(l.LDicke); }
    72. 

  72. 

  73. #define SWAPAREA(a) {               \
    74. 

  74.     a.FDummy2=SWAPSHORT(a.FDummy2); \
    75. 

  75.     a.FMuster=SWAPSHORT(a.FMuster); }
    76. 

  76. 

  77. #define SWAPTEXT(t) {               \
    78. 

  78.     SWAPLINE(t.L);                  \
    79. 

  79.     SWAPAREA(t.F);                  \
    80. 

  80.     t.FontLo =SWAPSHORT(t.FontLo ); \
    81. 

  81.     t.FontHi =SWAPSHORT(t.FontHi ); \
    82. 

  82.     t.Grad   =SWAPSHORT(t.Grad   ); \
    83. 

  83.     t.Breite =SWAPSHORT(t.Breite ); \
    84. 

  84.     t.Schnitt=SWAPSHORT(t.Schnitt); \
    85. 

  85.     t.LnFeed =SWAPSHORT(t.LnFeed ); \
    86. 

  86.     t.Slant  =SWAPSHORT(t.Slant  ); \
    87. 

  87.     SWAPLINE(t.ShdL);               \
    88. 

  88.     SWAPAREA(t.ShdF);               \
    89. 

  89.     SWAPPOINT(t.ShdVers);           \
    90. 

  90.     SWAPAREA(t.BackF);              }
    91. 

  91. 

  92. 

  93. ////////////////////////////////////////////////////////////////////////////////////////////////////
    94. 

  94. //
    95. 

  95. //  Einschraenkungen:
    96. 

  96. //
    97. 

  97. //  - Flaechenmuster werden den unter StarView verfuegbaren Mustern angenaehert.
    98. 

  98. //  - Linienenden werden unter StarView immer rund dargestellt und gehen ueber
    99. 

  99. //    den Endpunkt der Linie hinaus.
    100. 

  100. //  - Linienmuster werden den unter StarView verfuegbaren Mustern angenaehert.
    101. 

  101. //    Transparent/Opak wird zur Zeit noch nicht beruecksichtigt.
    102. 

  102. //  - Keine gedrehten Ellipsen
    103. 

  103. //
    104. 

  104. //
    105. 

  105. //
    106. 

  106. //
    107. 

  107. ////////////////////////////////////////////////////////////////////////////////////////////////////
    108. 

  108. 

  109. #if defined( WIN ) && defined( MSC )
    110. 

  110. #pragma code_seg( "svtools", "AUTO_CODE" )
    111. 

  111. #endif
    112. 

  112. 

  113. ////////////////////////////////////////////////////////////////////////////////////////////////////
    114. 

  114. // Fuer Fontuebersetzung ///////////////////////////////////////////////////////////////////////////
    115. 

  115. ////////////////////////////////////////////////////////////////////////////////////////////////////
    116. 

  116. SgfFontLst* pSgfFonts = 0;
    117. 

  117. 

  118. #if defined( WIN ) && defined( MSC )
    119. 

  119. #pragma code_seg( "SVTOOLS_FILTER3", "SVTOOLS_CODE" )
    120. 

  120. static void AntiMscBug() {}
    121. 

  121. #endif
    122. 

  122. 

  123. ////////////////////////////////////////////////////////////////////////////////////////////////////
    124. 

  124. // Fuer Kreisunterarten, Text und gedrehte Rechtecke ///////////////////////////////////////////////
    125. 

  125. ////////////////////////////////////////////////////////////////////////////////////////////////////
    126. 

  126. void RotatePoint(PointType& P, INT16 cx, INT16 cy, double sn, double cs)
    127. 

  127. {
    128. 

  128.     INT16  dx,dy;
    129. 

  129.     double x1,y1;
    130. 

  130.     dx=P.x-cx;
    131. 

  131.     dy=P.y-cy;
    132. 

  132.     x1=dx*cs-dy*sn;
    133. 

  133.     y1=dy*cs+dx*sn;
    134. 

  134.     P.x=cx+INT16(x1);
    135. 

  135.     P.y=cy+INT16(y1);
    136. 

  136. }
    137. 

  137. 

  138. void RotatePoint(Point& P, INT16 cx, INT16 cy, double sn, double cs)
    139. 

  139. {
    140. 

  140.     INT16  dx,dy;
    141. 

  141.     double x1,y1;
    142. 

  142.     dx=(INT16)(P.X()-cx);
    143. 

  143.     dy=(INT16)(P.Y()-cy);
    144. 

  144.     x1=dx*cs-dy*sn;
    145. 

  145.     y1=dy*cs+dx*sn;
    146. 

  146.     P=Point(cx+INT16(x1),cy+INT16(y1));
    147. 

  147. }
    148. 

  148. 

  149. INT16 iMulDiv(INT16 a, INT16 Mul, INT16 Div)
    150. 

  150. {
    151. 

  151.     INT32 Temp;
    152. 

  152.     Temp=INT32(a)*INT32(Mul)/INT32(Div);
    153. 

  153.     return INT16(Temp);
    154. 

  154. }
    155. 

  155. 

  156. UINT16 MulDiv(UINT16 a, UINT16 Mul, UINT16 Div)
    157. 

  157. {
    158. 

  158.     UINT32 Temp;
    159. 

  159.     Temp=UINT32(a)*UINT32(Mul)/UINT32(Div);
    160. 

  160.     return UINT16(Temp);
    161. 

  161. }
    162. 

  162. 

  163. ////////////////////////////////////////////////////////////////////////////////////////////////////
    164. 

  164. // SgfFilterSDrw ///////////////////////////////////////////////////////////////////////////////////
    165. 

  165. ////////////////////////////////////////////////////////////////////////////////////////////////////
    166. 

  166. 

  167. SvStream& operator>>(SvStream& rIStream, DtHdType& rDtHd)
    168. 

  168. {
    169. 

  169.     rIStream.Read((char*)&rDtHd.Reserved[0],DtHdSize);
    170. 

  170.     return rIStream;
    171. 

  171. }
    172. 

  172. 

  173. void DtHdOverSeek(SvStream& rInp)
    174. 

  174. {
    175. 

  175.     ULONG FPos=rInp.Tell();
    176. 

  176.     FPos+=(ULONG)DtHdSize;
    177. 

  177.     rInp.Seek(FPos);
    178. 

  178. //    rInp.seekg(rInp.tellg()+(ULONG)DtHdSize);
    179. 

  179. }
    180. 

  180. 

  181. 

  182. SvStream& operator>>(SvStream& rIStream, PageType& rPage)
    183. 

  183. {
    184. 

  184.     rIStream.Read((char*)&rPage.Next,PageSize);
    185. 

  185. #if defined OSL_BIGENDIAN
    186. 

  186.     SWAPPAGE(rPage);
    187. 

  187. #endif
    188. 

  188.     return rIStream;
    189. 

  189. }
    190. 

  190. 

  191. void ObjkOverSeek(SvStream& rInp, ObjkType& rObjk)
    192. 

  192. {
    193. 

  193.     ULONG Siz;
    194. 

  194.     Siz=(ULONG)rObjk.MemSize+rObjk.Last;  // ObjSize+ObjAnhSize
    195. 

  195.     rInp.Seek(rInp.Tell()+Siz);
    196. 

  196. }
    197. 

  197. 

  198. SvStream& operator>>(SvStream& rInp, ObjkType& rObjk)
    199. 

  199. {   // Die Fileposition im Stream bleibt unveraendert!
    200. 

  200.     ULONG nPos;
    201. 

  201.     nPos=rInp.Tell();
    202. 

  202.     rInp.Read((char*)&rObjk.Last,ObjkSize);
    203. 

  203. #if defined OSL_BIGENDIAN
    204. 

  204.     SWAPOBJK(rObjk);
    205. 

  205. #endif
    206. 

  206. #ifdef InArbeit
    207. 

  207.     ULONG nPos1=rInp.Tell();
    208. 

  208.     if(nPos == nPos1) InfoBox( NULL, "tellg funkt nich" ).Execute();
    209. 

  209. #endif
    210. 

  210.     rInp.Seek(nPos);
    211. 

  211. #ifdef InArbeit
    212. 

  212.     if (rInp.Tell() != nPos) InfoBox( NULL, "seekg funkt nich" ).Execute();
    213. 

  213. #endif
    214. 

  214.     return rInp;
    215. 

  215. }
    216. 

  216. SvStream& operator>>(SvStream& rInp, StrkType& rStrk)
    217. 

  217. {
    218. 

  218.     rInp.Read((char*)&rStrk.Last,StrkSize);
    219. 

  219. #if defined OSL_BIGENDIAN
    220. 

  220.     SWAPOBJK (rStrk);
    221. 

  221.     SWAPLINE (rStrk.L);
    222. 

  222.     SWAPPOINT(rStrk.Pos1);
    223. 

  223.     SWAPPOINT(rStrk.Pos2);
    224. 

  224. #endif
    225. 

  225.     return rInp;
    226. 

  226. }
    227. 

  227. SvStream& operator>>(SvStream& rInp, RectType& rRect)
    228. 

  228. {
    229. 

  229.     rInp.Read((char*)&rRect.Last,RectSize);
    230. 

  230. #if defined OSL_BIGENDIAN
    231. 

  231.     SWAPOBJK (rRect);
    232. 

  232.     SWAPLINE (rRect.L);
    233. 

  233.     SWAPAREA (rRect.F);
    234. 

  234.     SWAPPOINT(rRect.Pos1);
    235. 

  235.     SWAPPOINT(rRect.Pos2);
    236. 

  236.     rRect.Radius  =SWAPSHORT(rRect.Radius  );
    237. 

  237.     rRect.DrehWink=SWAPSHORT(rRect.DrehWink);
    238. 

  238.     rRect.Slant   =SWAPSHORT(rRect.Slant   );
    239. 

  239. #endif
    240. 

  240.     return rInp;
    241. 

  241. }
    242. 

  242. SvStream& operator>>(SvStream& rInp, PolyType& rPoly)
    243. 

  243. {
    244. 

  244.     rInp.Read((char*)&rPoly.Last,PolySize);
    245. 

  245. #if defined OSL_BIGENDIAN
    246. 

  246.     SWAPOBJK (rPoly);
    247. 

  247.     SWAPLINE (rPoly.L);
    248. 

  248.     SWAPAREA (rPoly.F);
    249. 

  249.     // rPoly.EckP=SWAPLONG(rPoly.EckP);
    250. 

  250. #endif
    251. 

  251.     return rInp;
    252. 

  252. }
    253. 

  253. SvStream& operator>>(SvStream& rInp, SplnType& rSpln)
    254. 

  254. {
    255. 

  255.     rInp.Read((char*)&rSpln.Last,SplnSize);
    256. 

  256. #if defined OSL_BIGENDIAN
    257. 

  257.     SWAPOBJK (rSpln);
    258. 

  258.     SWAPLINE (rSpln.L);
    259. 

  259.     SWAPAREA (rSpln.F);
    260. 

  260.     // rSpln.EckP=SWAPLONG(rSpln.EckP);
    261. 

  261. #endif
    262. 

  262.     return rInp;
    263. 

  263. }
    264. 

  264. SvStream& operator>>(SvStream& rInp, CircType& rCirc)
    265. 

  265. {
    266. 

  266.     rInp.Read((char*)&rCirc.Last,CircSize);
    267. 

  267. #if defined OSL_BIGENDIAN
    268. 

  268.     SWAPOBJK (rCirc);
    269. 

  269.     SWAPLINE (rCirc.L);
    270. 

  270.     SWAPAREA (rCirc.F);
    271. 

  271.     SWAPPOINT(rCirc.Radius);
    272. 

  272.     SWAPPOINT(rCirc.Center);
    273. 

  273.     rCirc.DrehWink =SWAPSHORT(rCirc.DrehWink );
    274. 

  274.     rCirc.StartWink=SWAPSHORT(rCirc.StartWink);
    275. 

  275.     rCirc.RelWink  =SWAPSHORT(rCirc.RelWink  );
    276. 

  276. #endif
    277. 

  277.     return rInp;
    278. 

  278. }
    279. 

  279. SvStream& operator>>(SvStream& rInp, TextType& rText)
    280. 

  280. {
    281. 

  281.     rInp.Read((char*)&rText.Last,TextSize);
    282. 

  282. #if defined OSL_BIGENDIAN
    283. 

  283.     SWAPOBJK (rText);
    284. 

  284.     SWAPTEXT (rText.T);
    285. 

  285.     SWAPPOINT(rText.Pos1);
    286. 

  286.     SWAPPOINT(rText.Pos2);
    287. 

  287.     rText.TopOfs  =SWAPSHORT(rText.TopOfs  );
    288. 

  288.     rText.DrehWink=SWAPSHORT(rText.DrehWink);
    289. 

  289.     rText.BoxSlant=SWAPSHORT(rText.BoxSlant);
    290. 

  290.     rText.BufSize =SWAPSHORT(rText.BufSize );
    291. 

  291.     //rText.Buf     =SWAPLONG (rText.Buf     );
    292. 

  292.     //rText.Ext     =SWAPLONG (rText.Ext     );
    293. 

  293.     SWAPPOINT(rText.FitSize);
    294. 

  294.     rText.FitBreit=SWAPSHORT(rText.FitBreit);
    295. 

  295. #endif
    296. 

  296.     rText.Buffer=NULL;
    297. 

  297.     return rInp;
    298. 

  298. }
    299. 

  299. SvStream& operator>>(SvStream& rInp, BmapType& rBmap)
    300. 

  300. {
    301. 

  301.     rInp.Read((char*)&rBmap.Last,BmapSize);
    302. 

  302. #if defined OSL_BIGENDIAN
    303. 

  303.     SWAPOBJK (rBmap);
    304. 

  304.     SWAPAREA (rBmap.F);
    305. 

  305.     SWAPPOINT(rBmap.Pos1);
    306. 

  306.     SWAPPOINT(rBmap.Pos2);
    307. 

  307.     rBmap.DrehWink=SWAPSHORT(rBmap.DrehWink);
    308. 

  308.     rBmap.Slant   =SWAPSHORT(rBmap.Slant   );
    309. 

  309.     SWAPPOINT(rBmap.PixSize);
    310. 

  310. #endif
    311. 

  311.     return rInp;
    312. 

  312. }
    313. 

  313. SvStream& operator>>(SvStream& rInp, GrupType& rGrup)
    314. 

  314. {
    315. 

  315.     rInp.Read((char*)&rGrup.Last,GrupSize);
    316. 

  316. #if defined OSL_BIGENDIAN
    317. 

  317.     SWAPOBJK (rGrup);
    318. 

  318.     rGrup.SbLo     =SWAPSHORT(rGrup.SbLo     );
    319. 

  319.     rGrup.SbHi     =SWAPSHORT(rGrup.SbHi     );
    320. 

  320.     rGrup.UpLo     =SWAPSHORT(rGrup.UpLo     );
    321. 

  321.     rGrup.UpHi     =SWAPSHORT(rGrup.UpHi     );
    322. 

  322.     rGrup.ChartSize=SWAPSHORT(rGrup.ChartSize);
    323. 

  323.     rGrup.ChartPtr =SWAPLONG (rGrup.ChartPtr );
    324. 

  324. #endif
    325. 

  325.     return rInp;
    326. 

  326. }
    327. 

  327. 

  328. 

  329. 

  330. /*************************************************************************
    331. 

  331. |*
    332. 

  332. |*    Sgv2SvFarbe()
    333. 

  333. |*
    334. 

  334. *************************************************************************/
    335. 

  335. Color Sgv2SvFarbe(BYTE nFrb1, BYTE nFrb2, BYTE nInts)
    336. 

  336. {
    337. 

  337.     UINT16 r1=0,g1=0,b1=0,r2=0,g2=0,b2=0;
    338. 

  338.     BYTE   nInt2=100-nInts;
    339. 

  339.     switch(nFrb1 & 0x07) {
    340. 

  340.         case 0:  r1=0xFF; g1=0xFF; b1=0xFF; break;
    341. 

  341.         case 1:  r1=0xFF; g1=0xFF;            break;
    342. 

  342.         case 2:           g1=0xFF; b1=0xFF; break;
    343. 

  343.         case 3:           g1=0xFF;            break;
    344. 

  344.         case 4:  r1=0xFF;          b1=0xFF; break;
    345. 

  345.         case 5:  r1=0xFF;                       break;
    346. 

  346.         case 6:                    b1=0xFF; break;
    347. 

  347.         case 7:                                   break;
    348. 

  348.     }
    349. 

  349.     switch(nFrb2 & 0x07) {
    350. 

  350.         case 0:  r2=0xFF; g2=0xFF; b2=0xFF; break;
    351. 

  351.         case 1:  r2=0xFF; g2=0xFF;            break;
    352. 

  352.         case 2:           g2=0xFF; b2=0xFF; break;
    353. 

  353.         case 3:           g2=0xFF;            break;
    354. 

  354.         case 4:  r2=0xFF;          b2=0xFF; break;
    355. 

  355.         case 5:  r2=0xFF;                       break;
    356. 

  356.         case 6:                    b2=0xFF; break;
    357. 

  357.         case 7:                                   break;
    358. 

  358.     }
    359. 

  359.     r1=(UINT16)((UINT32)r1*nInts/100+(UINT32)r2*nInt2/100);
    360. 

  360.     g1=(UINT16)((UINT32)g1*nInts/100+(UINT32)g2*nInt2/100);
    361. 

  361.     b1=(UINT16)((UINT32)b1*nInts/100+(UINT32)b2*nInt2/100);
    362. 

  362.     Color aColor( (sal_uInt8)r1, (sal_uInt8)g1, (sal_uInt8)b1 );
    363. 

  363.     return aColor;
    364. 

  364. }
    365. 

  365. 

  366. void SetLine(ObjLineType& rLine, OutputDevice& rOut)
    367. 

  367. {
    368. 

  368. /* !!!
    369. 

  369.     PenStyle aStyle=PEN_SOLID;
    370. 

  370.     switch(rLine.LMuster & 0x07) {
    371. 

  371.         case 0: aStyle=PEN_NULL;    break;
    372. 

  372.         case 1: aStyle=PEN_SOLID;   break;
    373. 

  373.         case 2: aStyle=PEN_DOT;     break;    // . . . . . . . . . . . . . .
    374. 

  374.         case 3: aStyle=PEN_DASH;    break;    // __ __ __ __ __ __ __ __ __
    375. 

  375.         case 4: aStyle=PEN_DASH;    break;    // ___ ___ ___ ___ ___ ___ ___
    376. 

  376.         case 5: aStyle=PEN_DASHDOT; break;    // __ . __ . __ . __ . __ . __
    377. 

  377.         case 6: aStyle=PEN_DASHDOT; break;    // __ _ __ _ __ _ __ _ __ _ __
    378. 

  378.         case 7: aStyle=PEN_DASHDOT; break;    // ___ _ _ ___ _ _ ___ _ _ ___
    379. 

  379.     }
    380. 

  380.     Pen aPen(Sgv2SvFarbe(rLine.LFarbe,rLine.LBFarbe,rLine.LIntens),rLine.LDicke,aStyle);
    381. 

  381.     SetPen(aPen,rOut);
    382. 

  382. */
    383. 

  383.     if( 0 == ( rLine.LMuster & 0x07 ) )
    384. 

  384.         rOut.SetLineColor();
    385. 

  385.     else
    386. 

  386.         rOut.SetLineColor( Sgv2SvFarbe(rLine.LFarbe,rLine.LBFarbe,rLine.LIntens) );
    387. 

  387. }
    388. 

  388. 

  389. void SetArea(ObjAreaType& rArea, OutputDevice& rOut)
    390. 

  390. {
    391. 

  391. /*
    392. 

  392.     BrushStyle aStyle=BRUSH_SOLID;
    393. 

  393.     switch(rArea.FMuster & 0x00FF) {
    394. 

  394.         case  0: aStyle=BRUSH_NULL;      break;
    395. 

  395.         case  1: aStyle=BRUSH_SOLID;     break;
    396. 

  396.         case  2: case  4: case  6: case  8:
    397. 

  397.         case 10: case 12: case 14: case 16:
    398. 

  398.         case 43: case 45:                   aStyle=BRUSH_VERT;      break;
    399. 

  399.         case  3: case  5: case  7: case  9:
    400. 

  400.         case 11: case 13: case 15: case 17:
    401. 

  401.         case 42: case 44:                   aStyle=BRUSH_HORZ;      break;
    402. 

  402.         case 18: case 20: case 22: case 24:
    403. 

  403.         case 26: case 28: case 30: case 32:
    404. 

  404.         case 46: case 48:                   aStyle=BRUSH_UPDIAG;    break;
    405. 

  405.         case 19: case 21: case 23: case 25:
    406. 

  406.         case 27: case 29: case 31: case 33:
    407. 

  407.         case 47: case 49:                   aStyle=BRUSH_DOWNDIAG;  break;
    408. 

  408.         case 34: case 35: case 36: case 37: aStyle=BRUSH_CROSS;     break;
    409. 

  409.         case 38: case 39: case 40: case 41: aStyle=BRUSH_DIAGCROSS; break;
    410. 

  410.         default: aStyle=BRUSH_DIAGCROSS; break;
    411. 

  411.     }
    412. 

  412.     Brush aBrush(Sgv2SvFarbe(rArea.FFarbe,rArea.FBFarbe,rArea.FIntens),aStyle);
    413. 

  413.     aBrush.SetTransparent((rArea.FMuster & 0x80) !=0L);
    414. 

  414.     SetBrush(aBrush,rOut);
    415. 

  415. */
    416. 

  416.     if( 0 == ( rArea.FMuster & 0x00FF ) )
    417. 

  417.         rOut.SetFillColor();
    418. 

  418.     else
    419. 

  419.         rOut.SetFillColor( Sgv2SvFarbe( rArea.FFarbe,rArea.FBFarbe,rArea.FIntens ) );
    420. 

  420. }
    421. 

  421. 

  422. /*************************************************************************
    423. 

  423. |*
    424. 

  424. |*    ObjkType::DrawObjekt()
    425. 

  425. |*
    426. 

  426. *************************************************************************/
    427. 

  427. void ObjkType::Draw(OutputDevice&)
    428. 

  428. {
    429. 

  429. //    ShowSDObjk(*this);
    430. 

  430. }
    431. 

  431. 

  432. void Obj0Type::Draw(OutputDevice&) {}
    433. 

  433. 

  434. /*************************************************************************
    435. 

  435. |*
    436. 

  436. |*    StrkType::DrawObjekt()
    437. 

  437. |*
    438. 

  438. *************************************************************************/
    439. 

  439. void StrkType::Draw(OutputDevice& rOut)
    440. 

  440. {
    441. 

  441.     SetLine(L,rOut);
    442. 

  442.     rOut.DrawLine(Point(Pos1.x,Pos1.y),Point(Pos2.x,Pos2.y)); // !!!
    443. 

  443. }
    444. 

  444. 

  445. /*************************************************************************
    446. 

  446. |*
    447. 

  447. |*    RectType::DrawObjekt()
    448. 

  448. |*
    449. 

  449. *************************************************************************/
    450. 

  450. void SgfAreaColorIntens(UINT16 Muster, BYTE Col1, BYTE Col2, BYTE Int, OutputDevice& rOut)
    451. 

  451. {
    452. 

  452.     ObjAreaType F;
    453. 

  453.     F.FMuster=Muster;
    454. 

  454.     F.FFarbe=Col2;
    455. 

  455.     F.FBFarbe=Col1;
    456. 

  456.     F.FIntens=Int;
    457. 

  457.     SetArea(F,rOut);
    458. 

  458. }
    459. 

  459. 

  460. void DrawSlideRect(INT16 x1, INT16 y1, INT16 x2, INT16 y2, ObjAreaType& F, OutputDevice& rOut)
    461. 

  461. {
    462. 

  462.     INT16 i,i0,b,b0;
    463. 

  463.     INT16 Int1,Int2;
    464. 

  464.     INT16 Col1,Col2;
    465. 

  465.     //     ClipMerk: HgdClipRec;
    466. 

  466.     INT16 cx,cy;
    467. 

  467.     INT16 MaxR;
    468. 

  468.     INT32 dx,dy;
    469. 

  469. 

  470.     rOut.SetLineColor();
    471. 

  471.     if (x1>x2) { i=x1; x1=x2; x2=i; }
    472. 

  472.     if (y1>y2) { i=y1; y1=y2; y2=i; }
    473. 

  473.     Col1=F.FBFarbe & 0x87; Col2=F.FFarbe & 0x87;
    474. 

  474.     Int1=100-F.FIntens; Int2=F.FIntens;
    475. 

  475.     if (Int1==Int2) {
    476. 

  476.         SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)Int2,rOut);
    477. 

  477.         rOut.DrawRect(Rectangle(x1,y1,x2,y2));
    478. 

  478.     } else {
    479. 

  479.         b0=Int1;
    480. 

  480.         switch (F.FBFarbe & 0x38) {
    481. 

  481.             case 0x08: { // vertikal
    482. 

  482.                 i0=y1;
    483. 

  483.                 i=y1;
    484. 

  484.                 while (i<=y2) {
    485. 

  485.                     b=Int1+INT16((INT32)(Int2-Int1)*(INT32)(i-y1) /(INT32)(y2-y1+1));
    486. 

  486.                     if (b!=b0) {
    487. 

  487.                         SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)b0,rOut);
    488. 

  488.                         rOut.DrawRect(Rectangle(x1,i0,x2,i-1));
    489. 

  489.                         i0=i; b0=b;
    490. 

  490.                     }
    491. 

  491.                     i++;
    492. 

  492.                 }
    493. 

  493.                 SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)Int2,rOut);
    494. 

  494.                 rOut.DrawRect(Rectangle(x1,i0,x2,y2));
    495. 

  495.             } break;
    496. 

  496.             case 0x28: { // horizontal
    497. 

  497.                 i0=x1;
    498. 

  498.                 i=x1;
    499. 

  499.                 while (i<=x2) {
    500. 

  500.                     b=Int1+INT16((INT32)(Int2-Int1)*(INT32)(i-x1) /(INT32)(x2-x1+1));
    501. 

  501.                     if (b!=b0) {
    502. 

  502.                         SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)b0,rOut);
    503. 

  503.                         rOut.DrawRect(Rectangle(i0,y1,i-1,y2));
    504. 

  504.                         i0=i; b0=b;
    505. 

  505.                     }
    506. 

  506.                     i++;
    507. 

  507.                 }
    508. 

  508.                 SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)Int2,rOut);
    509. 

  509.                 rOut.DrawRect(Rectangle(i0,y1,x2,y2));
    510. 

  510.             } break;
    511. 

  511. 

  512.             case 0x18: case 0x38: { // Kreis
    513. 

  513.                 Region ClipMerk=rOut.GetClipRegion();
    514. 

  514.                 double a;
    515. 

  515. 

  516.                 rOut.SetClipRegion(Region(Rectangle(x1,y1,x2,y2)));
    517. 

  517.                 cx=(x1+x2) /2;
    518. 

  518.                 cy=(y1+y2) /2;
    519. 

  519.                 dx=x2-x1+1;
    520. 

  520.                 dy=y2-y1+1;
    521. 

  521.                 a=sqrt((double)(dx*dx+dy*dy));
    522. 

  522.                 MaxR=INT16(a) /2 +1;
    523. 

  523.                 b0=Int2;
    524. 

  524.                 i0=MaxR; if (MaxR<1) MaxR=1;
    525. 

  525.                 i=MaxR;
    526. 

  526.                 while (i>=0) {
    527. 

  527.                     b=Int1+INT16((INT32(Int2-Int1)*INT32(i)) /INT32(MaxR));
    528. 

  528.                     if (b!=b0) {
    529. 

  529.                         SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)b0,rOut);
    530. 

  530.                         //if (i0>200 || (Col1 & $80)!=0 || (Col2 & $80)!=0) {
    531. 

  531.                         //  then begin { Fallunterscheidung fuer etwas bessere Performance }
    532. 

  532.                         //    s2:=i0-i+2;
    533. 

  533.                         //    SetPenSize(s2);
    534. 

  534.                         //    s2:=s2 div 2;
    535. 

  535.                         //    Circle(cx,cy,i0-s2,i0-s2);{}
    536. 

  536.                         //  else
    537. 

  537.                         rOut.DrawEllipse(Rectangle(cx-i0,cy-i0,cx+i0,cy+i0));
    538. 

  538.                         i0=i; b0=b;
    539. 

  539.                     }
    540. 

  540.                     i--;
    541. 

  541.                 }
    542. 

  542.                 SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)Int1,rOut);
    543. 

  543.                 rOut.DrawEllipse(Rectangle(cx-i0,cy-i0,cx+i0,cy+i0));
    544. 

  544.                 rOut.SetClipRegion(ClipMerk);
    545. 

  545.             } break; // Kreis
    546. 

  546.         }
    547. 

  547.     }
    548. 

  548. }
    549. 

  549. 

  550. 

  551. void RectType::Draw(OutputDevice& rOut)
    552. 

  552. {
    553. 

  553.     if (L.LMuster!=0) L.LMuster=1; // keine Linienmuster hier, nur an oder aus
    554. 

  554.     SetArea(F,rOut);
    555. 

  555.     if (DrehWink==0) {
    556. 

  556.     if ((F.FBFarbe & 0x38)==0 || Radius!=0) {
    557. 

  557.             SetLine(L,rOut);
    558. 

  558.             rOut.DrawRect(Rectangle(Pos1.x,Pos1.y,Pos2.x,Pos2.y),Radius,Radius);
    559. 

  559.         } else {
    560. 

  560.             DrawSlideRect(Pos1.x,Pos1.y,Pos2.x,Pos2.y,F,rOut);
    561. 

  561.             if (L.LMuster!=0) {
    562. 

  562.                 SetLine(L,rOut);
    563. 

  563.                 rOut.SetFillColor();
    564. 

  564.                 rOut.DrawRect(Rectangle(Pos1.x,Pos1.y,Pos2.x,Pos2.y));
    565. 

  565.             }
    566. 

  566.         }
    567. 

  567.     } else {
    568. 

  568.         Point  aPts[4];
    569. 

  569.         USHORT i;
    570. 

  570.         double sn,cs;
    571. 

  571.         sn=sin(double(DrehWink)*3.14159265359/18000);
    572. 

  572.         cs=cos(double(DrehWink)*3.14159265359/18000);
    573. 

  573.         aPts[0]=Point(Pos1.x,Pos1.y);
    574. 

  574.         aPts[1]=Point(Pos2.x,Pos1.y);
    575. 

  575.         aPts[2]=Point(Pos2.x,Pos2.y);
    576. 

  576.         aPts[3]=Point(Pos1.x,Pos2.y);
    577. 

  577.         for (i=0;i<4;i++) {
    578. 

  578.             RotatePoint(aPts[i],Pos1.x,Pos1.y,sn,cs);
    579. 

  579.         }
    580. 

  580.         SetLine(L,rOut);
    581. 

  581.         Polygon aPoly(4,aPts);
    582. 

  582.         rOut.DrawPolygon(aPoly);
    583. 

  583.     }
    584. 

  584. }
    585. 

  585. 

  586. /*************************************************************************
    587. 

  587. |*
    588. 

  588. |*    PolyType::Draw()
    589. 

  589. |*
    590. 

  590. *************************************************************************/
    591. 

  591. void PolyType::Draw(OutputDevice& rOut)
    592. 

  592. {
    593. 

  593.     if ((Flags & PolyClosBit) !=0) SetArea(F,rOut);
    594. 

  594.     SetLine(L,rOut);
    595. 

  595.     Polygon aPoly(nPoints);
    596. 

  596.     USHORT i;
    597. 

  597.     for(i=0;i<nPoints;i++) aPoly.SetPoint(Point(EckP[i].x,EckP[i].y),i);
    598. 

  598.     if ((Flags & PolyClosBit) !=0) {
    599. 

  599.         rOut.DrawPolygon(aPoly);
    600. 

  600.     } else {
    601. 

  601.         rOut.DrawPolyLine(aPoly);
    602. 

  602.     }
    603. 

  603. }
    604. 

  604. 

  605. /*************************************************************************
    606. 

  606. |*
    607. 

  607. |*    SplnType::Draw()
    608. 

  608. |*
    609. 

  609. *************************************************************************/
    610. 

  610. void SplnType::Draw(OutputDevice& rOut)
    611. 

  611. {
    612. 

  612.     if ((Flags & PolyClosBit) !=0) SetArea(F,rOut);
    613. 

  613.     SetLine(L,rOut);
    614. 

  614.     Polygon aPoly(0);
    615. 

  615.     Polygon aSpln(nPoints);
    616. 

  616.     USHORT i;
    617. 

  617.     for(i=0;i<nPoints;i++) aSpln.SetPoint(Point(EckP[i].x,EckP[i].y),i);
    618. 

  618.     if ((Flags & PolyClosBit) !=0) {
    619. 

  619.         Spline2Poly(aSpln,TRUE,aPoly);
    620. 

  620.         if (aPoly.GetSize()>0) rOut.DrawPolygon(aPoly);
    621. 

  621.     } else {
    622. 

  622.         Spline2Poly(aSpln,FALSE,aPoly);
    623. 

  623.         if (aPoly.GetSize()>0) rOut.DrawPolyLine(aPoly);
    624. 

  624.     }
    625. 

  625. }
    626. 

  626. 

  627. /*************************************************************************
    628. 

  628. |*
    629. 

  629. |*    CircType::Draw()
    630. 

  630. |*
    631. 

  631. *************************************************************************/
    632. 

  632. void DrawSlideCirc(INT16 cx, INT16 cy, INT16 rx, INT16 ry, ObjAreaType& F, OutputDevice& rOut)
    633. 

  633. {
    634. 

  634.     INT16 x1=cx-rx;
    635. 

  635.     INT16 y1=cy-ry;
    636. 

  636.     INT16 x2=cx+rx;
    637. 

  637.     INT16 y2=cy+ry;
    638. 

  638. 

  639.     INT16 i,i0,b,b0;
    640. 

  640.     INT16 Int1,Int2;
    641. 

  641.     INT16 Col1,Col2;
    642. 

  642. 

  643.     rOut.SetLineColor();
    644. 

  644.     Col1=F.FBFarbe & 0x87; Col2=F.FFarbe & 0x87;
    645. 

  645.     Int1=100-F.FIntens; Int2=F.FIntens;
    646. 

  646.     if (Int1==Int2) {
    647. 

  647.         SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)Int2,rOut);
    648. 

  648.         rOut.DrawEllipse(Rectangle(x1,y1,x2,y2));
    649. 

  649.     } else {
    650. 

  650.         b0=Int1;
    651. 

  651.         switch (F.FBFarbe & 0x38) {
    652. 

  652.             case 0x08: { // vertikal
    653. 

  653.                 Region ClipMerk=rOut.GetClipRegion();
    654. 

  654.                 i0=y1;
    655. 

  655.                 i=y1;
    656. 

  656.                 while (i<=y2) {
    657. 

  657.                     b=Int1+INT16((INT32)(Int2-Int1)*(INT32)(i-y1) /(INT32)(y2-y1+1));
    658. 

  658.                     if (b!=b0) {
    659. 

  659.                         SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)b0,rOut);
    660. 

  660.                         rOut.SetClipRegion(Rectangle(x1,i0,x2,i-1));
    661. 

  661.                         rOut.DrawEllipse(Rectangle(x1,y1,x2,y2));
    662. 

  662.                         i0=i; b0=b;
    663. 

  663.                     }
    664. 

  664.                     i++;
    665. 

  665.                 }
    666. 

  666.                 SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)Int2,rOut);
    667. 

  667.                 rOut.SetClipRegion(Rectangle(x1,i0,x2,y2));
    668. 

  668.                 rOut.DrawEllipse(Rectangle(x1,y1,x2,y2));
    669. 

  669.                 rOut.SetClipRegion(ClipMerk);
    670. 

  670.             } break;
    671. 

  671.             case 0x28: { // horizontal
    672. 

  672.                 Region ClipMerk=rOut.GetClipRegion();
    673. 

  673.                 i0=x1;
    674. 

  674.                 i=x1;
    675. 

  675.                 while (i<=x2) {
    676. 

  676.                     b=Int1+INT16((INT32)(Int2-Int1)*(INT32)(i-x1) /(INT32)(x2-x1+1));
    677. 

  677.                     if (b!=b0) {
    678. 

  678.                         SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)b0,rOut);
    679. 

  679.                         rOut.SetClipRegion(Rectangle(i0,y1,i-1,y2));
    680. 

  680.                         rOut.DrawEllipse(Rectangle(x1,y1,x2,y2));
    681. 

  681.                         i0=i; b0=b;
    682. 

  682.                     }
    683. 

  683.                     i++;
    684. 

  684.                 }
    685. 

  685.                 SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)Int2,rOut);
    686. 

  686.                 rOut.SetClipRegion(Rectangle(i0,y1,x2,y2));
    687. 

  687.                 rOut.DrawEllipse(Rectangle(x1,y1,x2,y2));
    688. 

  688.                 rOut.SetClipRegion(ClipMerk);
    689. 

  689.             } break;
    690. 

  690. 

  691.             case 0x18: case 0x38: { // Kreis
    692. 

  692.                 INT16 MaxR;
    693. 

  693. 

  694.                 if (rx<1) rx=1;
    695. 

  695.                 if (ry<1) ry=1;
    696. 

  696.                 MaxR=rx;
    697. 

  697.                 b0=Int2;
    698. 

  698.                 i0=MaxR; if (MaxR<1) MaxR=1;
    699. 

  699.                 i=MaxR;
    700. 

  700.                 while (i>=0) {
    701. 

  701.                     b=Int1+INT16((INT32(Int2-Int1)*INT32(i)) /INT32(MaxR));
    702. 

  702.                     if (b!=b0) {
    703. 

  703.                         INT32 temp=INT32(i0)*INT32(ry)/INT32(rx);
    704. 

  704.                         INT16 j0=INT16(temp);
    705. 

  705.                         SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)b0,rOut);
    706. 

  706.                         rOut.DrawEllipse(Rectangle(cx-i0,cy-j0,cx+i0,cy+j0));
    707. 

  707.                         i0=i; b0=b;
    708. 

  708.                     }
    709. 

  709.                     i--;
    710. 

  710.                 }
    711. 

  711.                 SgfAreaColorIntens(F.FMuster,(BYTE)Col1,(BYTE)Col2,(BYTE)Int1,rOut);
    712. 

  712.                 rOut.DrawEllipse(Rectangle(cx-i0,cy-i0,cx+i0,cy+i0));
    713. 

  713.             } break; // Kreis
    714. 

  714.         }
    715. 

  715.     }
    716. 

  716. }
    717. 

  717. 

  718. 

  719. void CircType::Draw(OutputDevice& rOut)
    720. 

  720. {
    721. 

  721.     Rectangle aRect(Center.x-Radius.x,Center.y-Radius.y,Center.x+Radius.x,Center.y+Radius.y);
    722. 

  722. 

  723.     if (L.LMuster!=0) L.LMuster=1; // keine Linienmuster hier, nur an oder aus
    724. 

  724.     SetArea(F,rOut);
    725. 

  725.     if ((Flags & 0x03)==CircFull) {
    726. 

  726.         if ((F.FBFarbe & 0x38)==0) {
    727. 

  727.             SetLine(L,rOut);
    728. 

  728.             rOut.DrawEllipse(aRect);
    729. 

  729.         } else {
    730. 

  730.             DrawSlideCirc(Center.x,Center.y,Radius.x,Radius.y,F,rOut);
    731. 

  731.             if (L.LMuster!=0) {
    732. 

  732.                 SetLine(L,rOut);
    733. 

  733.                 rOut.SetFillColor();
    734. 

  734.                 rOut.DrawEllipse(aRect);
    735. 

  735.             }
    736. 

  736.         }
    737. 

  737.     } else {
    738. 

  738.         PointType a,b;
    739. 

  739.         Point  aStrt,aEnde;
    740. 

  740.         double sn,cs;
    741. 

  741. 

  742.         a.x=Center.x+Radius.x; a.y=Center.y; b=a;
    743. 

  743.         sn=sin(double(StartWink)*3.14159265359/18000);
    744. 

  744.         cs=cos(double(StartWink)*3.14159265359/18000);
    745. 

  745.         RotatePoint(a,Center.x,Center.y,sn,cs);
    746. 

  746.         sn=sin(double(StartWink+RelWink)*3.14159265359/18000);
    747. 

  747.         cs=cos(double(StartWink+RelWink)*3.14159265359/18000);
    748. 

  748.         RotatePoint(b,Center.x,Center.y,sn,cs);
    749. 

  749.         if (Radius.x!=Radius.y) {
    750. 

  750.           if (Radius.x<1) Radius.x=1;
    751. 

  751.           if (Radius.y<1) Radius.y=1;
    752. 

  752.           a.y = a.y - Center.y;
    753. 

  753.           b.y = b.y - Center.y;
    754. 

  754.           a.y=iMulDiv(a.y,Radius.y,Radius.x);
    755. 

  755.           b.y=iMulDiv(b.y,Radius.y,Radius.x);
    756. 

  756.           a.y = a.y + Center.y;
    757. 

  757.           b.y = b.y + Center.y;
    758. 

  758.         }
    759. 

  759.         aStrt=Point(a.x,a.y);
    760. 

  760.         aEnde=Point(b.x,b.y);
    761. 

  761.         SetLine(L,rOut);
    762. 

  762.         switch (Flags & 0x03) {
    763. 

  763.             case CircArc : rOut.DrawArc(aRect,aEnde,aStrt); break;
    764. 

  764.             case CircSect:
    765. 

  765.             case CircAbsn: rOut.DrawPie(aRect,aEnde,aStrt); break;
    766. 

  766.         }
    767. 

  767.     }
    768. 

  768. }
    769. 

  769. 

  770. /*************************************************************************
    771. 

  771. |*
    772. 

  772. |*    BmapType::Draw()
    773. 

  773. |*
    774. 

  774. *************************************************************************/
    775. 

  775. 

  776. void BmapType::Draw(OutputDevice& rOut)
    777. 

  777. {
    778. 

  778.     //ifstream aInp;
    779. 

  779.     unsigned char   nSgfTyp;
    780. 

  780.     USHORT          nVersion;
    781. 

  781.     String          aStr(
    782. 

  782.         reinterpret_cast< char const * >(&Filename[ 1 ]),
    783. 

  783.         (xub_StrLen)Filename[ 0 ], RTL_TEXTENCODING_UTF8 );
    784. 

  784.     INetURLObject   aFNam( aStr );
    785. 

  785. 

  786.     SvStream* pInp = ::utl::UcbStreamHelper::CreateStream( aFNam.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ );
    787. 

  787.     if ( pInp )
    788. 

  788.     {
    789. 

  789.         nSgfTyp=CheckSgfTyp( *pInp,nVersion);
    790. 

  790.         switch(nSgfTyp) {
    791. 

  791.             case SGF_BITIMAGE: {
    792. 

  792.                 GraphicFilter aFlt;
    793. 

  793.                 Graphic aGrf;
    794. 

  794.                 aFlt.ImportGraphic(aGrf,aFNam);
    795. 

  795.                 aGrf.Draw(&rOut,Point(Pos1.x,Pos1.y),Size(Pos2.x-Pos1.x,Pos2.y-Pos1.y));
    796. 

  796.             } break;
    797. 

  797.             case SGF_SIMPVECT: {
    798. 

  798.                 GDIMetaFile aMtf;
    799. 

  799.                 SgfVectXofs=Pos1.x;
    800. 

  800.                 SgfVectYofs=Pos1.y;
    801. 

  801.                 SgfVectXmul=Pos2.x-Pos1.x;
    802. 

  802.                 SgfVectYmul=Pos2.y-Pos1.y;
    803. 

  803.                 SgfVectXdiv=0;
    804. 

  804.                 SgfVectYdiv=0;
    805. 

  805.                 SgfVectScal=TRUE;
    806. 

  806.                 SgfVectFilter(*pInp,aMtf);
    807. 

  807.                 SgfVectXofs=0;
    808. 

  808.                 SgfVectYofs=0;
    809. 

  809.                 SgfVectXmul=0;
    810. 

  810.                 SgfVectYmul=0;
    811. 

  811.                 SgfVectXdiv=0;
    812. 

  812.                 SgfVectYdiv=0;
    813. 

  813.                 SgfVectScal=FALSE;
    814. 

  814.                 aMtf.Play(&rOut);
    815. 

  815.             } break;
    816. 

  816.         }
    817. 

  817.         delete pInp;
    818. 

  818.     }
    819. 

  819. }
    820. 

  820. 

  821. 

  822. /*************************************************************************
    823. 

  823. |*
    824. 

  824. |*    GrupType::...
    825. 

  825. |*
    826. 

  826. *************************************************************************/
    827. 

  827. UINT32 GrupType::GetSubPtr()
    828. 

  828. {
    829. 

  829.     return UINT32(SbLo)+0x00010000*UINT32(SbHi);
    830. 

  830. }
    831. 

  831. 

  832. /*************************************************************************
    833. 

  833. |*
    834. 

  834. |*    DrawObjkList()
    835. 

  835. |*
    836. 

  836. *************************************************************************/
    837. 

  837. void DrawObjkList( SvStream& rInp, OutputDevice& rOut )
    838. 

  838. {
    839. 

  839.     ObjkType aObjk;
    840. 

  840.     USHORT nGrpCnt=0;
    841. 

  841.     BOOL bEnde=FALSE;
    842. 

  842.     do {
    843. 

  843.         rInp>>aObjk;
    844. 

  844.         if (!rInp.GetError()) {
    845. 

  845.             switch(aObjk.Art) {
    846. 

  846.                 case ObjStrk: { StrkType aStrk; rInp>>aStrk; if (!rInp.GetError()) aStrk.Draw(rOut); } break;
    847. 

  847.                 case ObjRect: { RectType aRect; rInp>>aRect; if (!rInp.GetError()) aRect.Draw(rOut); } break;
    848. 

  848.                 case ObjCirc: { CircType aCirc; rInp>>aCirc; if (!rInp.GetError()) aCirc.Draw(rOut); } break;
    849. 

  849.                 case ObjText: {
    850. 

  850.                     TextType aText;
    851. 

  851.                     rInp>>aText;
    852. 

  852.                     if (!rInp.GetError()) {
    853. 

  853.                         aText.Buffer=new UCHAR[aText.BufSize+1]; // Ein mehr fuer LookAhead bei CK-Trennung
    854. 

  854.                         rInp.Read((char* )aText.Buffer,aText.BufSize);
    855. 

  855.                         if (!rInp.GetError()) aText.Draw(rOut);
    856. 

  856.                         delete[] aText.Buffer;
    857. 

  857.                     }
    858. 

  858.                 } break;
    859. 

  859.                 case ObjBmap: {
    860. 

  860.                     BmapType aBmap;
    861. 

  861.                     rInp>>aBmap;
    862. 

  862.                     if (!rInp.GetError()) {
    863. 

  863.                         aBmap.Draw(rOut);
    864. 

  864.                     }
    865. 

  865.                 } break;
    866. 

  866.                 case ObjPoly: {
    867. 

  867.                     PolyType aPoly;
    868. 

  868.                     rInp>>aPoly;
    869. 

  869.                     if (!rInp.GetError()) {
    870. 

  870.                         aPoly.EckP=new PointType[aPoly.nPoints];
    871. 

  871.                         rInp.Read((char*)aPoly.EckP,4*aPoly.nPoints);
    872. 

  872. #if defined OSL_BIGENDIAN
    873. 

  873.                         for(short i=0;i<aPoly.nPoints;i++) SWAPPOINT(aPoly.EckP[i]);
    874. 

  874. #endif
    875. 

  875.                         if (!rInp.GetError()) aPoly.Draw(rOut);
    876. 

  876.                         delete[] aPoly.EckP;
    877. 

  877.                     }
    878. 

  878.                 } break;
    879. 

  879.                 case ObjSpln: {
    880. 

  880.                     SplnType aSpln;
    881. 

  881.                     rInp>>aSpln;
    882. 

  882.                     if (!rInp.GetError()) {
    883. 

  883.                         aSpln.EckP=new PointType[aSpln.nPoints];
    884. 

  884.                         rInp.Read((char*)aSpln.EckP,4*aSpln.nPoints);
    885. 

  885. #if defined OSL_BIGENDIAN
    886. 

  886.                         for(short i=0;i<aSpln.nPoints;i++) SWAPPOINT(aSpln.EckP[i]);
    887. 

  887. #endif
    888. 

  888.                         if (!rInp.GetError()) aSpln.Draw(rOut);
    889. 

  889.                         delete[] aSpln.EckP;
    890. 

  890.                     }
    891. 

  891.                 } break;
    892. 

  892.                 case ObjGrup: {
    893. 

  893.                     GrupType aGrup;
    894. 

  894.                     rInp>>aGrup;
    895. 

  895.                     if (!rInp.GetError()) {
    896. 

  896.                         rInp.Seek(rInp.Tell()+aGrup.Last); // Obj-Anhaengsel
    897. 

  897.                         if(aGrup.GetSubPtr()!=0L) nGrpCnt++;// DrawObjkList(rInp,rOut );
    898. 

  898.                     }
    899. 

  899.                 } break;
    900. 

  900.                 default: {
    901. 

  901.                     aObjk.Draw(rOut);          // Objektbezeichnung auf 2. Screen
    902. 

  902.                     ObjkOverSeek(rInp,aObjk);  // zum naechsten Objekt
    903. 

  903.                 }
    904. 

  904.             }
    905. 

  905.         } // if rInp
    906. 

  906.         if (!rInp.GetError()) {
    907. 

  907.             if (aObjk.Next==0L) {
    908. 

  908.                 if (nGrpCnt==0) bEnde=TRUE;
    909. 

  909.                 else nGrpCnt--;
    910. 

  910.             }
    911. 

  911.         } else {
    912. 

  912.             bEnde=TRUE;  // Lesefehler
    913. 

  913.         }
    914. 

  914.     } while (!bEnde);
    915. 

  915. }
    916. 

  916. 

  917. /*************************************************************************
    918. 

  918. |*
    919. 

  919. |*    SkipObjkList()
    920. 

  920. |*
    921. 

  921. *************************************************************************/
    922. 

  922. void SkipObjkList(SvStream& rInp)
    923. 

  923. {
    924. 

  924.     ObjkType aObjk;
    925. 

  925.     do
    926. 

  926.     {
    927. 

  927.         rInp>>aObjk;
    928. 

  928.         if(aObjk.Art==ObjGrup) {
    929. 

  929.             GrupType aGrup;
    930. 

  930.             rInp>>aGrup;
    931. 

  931.             rInp.Seek(rInp.Tell()+aGrup.Last); // Obj-Anhaengsel
    932. 

  932.             if(aGrup.GetSubPtr()!=0L) SkipObjkList(rInp);
    933. 

  933.         } else {
    934. 

  934.             ObjkOverSeek(rInp,aObjk);  // zum naechsten Objekt
    935. 

  935.         }
    936. 

  936.     } while (aObjk.Next!=0L && !rInp.GetError());
    937. 

  937. }
    938. 

  938. 

  939. /*************************************************************************
    940. 

  940. |*
    941. 

  941. |*    SgfFilterSDrw()
    942. 

  942. |*
    943. 

  943. *************************************************************************/
    944. 

  944. BOOL SgfFilterSDrw( SvStream& rInp, SgfHeader&, SgfEntry&, GDIMetaFile& rMtf )
    945. 

  945. {
    946. 

  946.     BOOL          bRet = FALSE;
    947. 

  947.     PageType      aPage;
    948. 

  948.     VirtualDevice aOutDev;
    949. 

  949.     OutputDevice* pOutDev;
    950. 

  950.     ULONG         nStdPos;
    951. 

  951.     ULONG         nZchPos;
    952. 

  952.     USHORT        Num;
    953. 

  953. 

  954.     pOutDev=&aOutDev;
    955. 

  955.     DtHdOverSeek(rInp); // DataHeader weglesen
    956. 

  956. 

  957.     nStdPos=rInp.Tell();
    958. 

  958.     do {                // Standardseiten weglesen
    959. 

  959.         rInp>>aPage;
    960. 

  960.         if (aPage.nList!=0) SkipObjkList(rInp);
    961. 

  961.     } while (aPage.Next!=0L && !rInp.GetError());
    962. 

  962. 

  963. //    ShowMsg("Zeichnungseite(n)\n");
    964. 

  964.     nZchPos=rInp.Tell();
    965. 

  965.     rInp>>aPage;
    966. 

  966. 

  967.     rMtf.Record(pOutDev);
    968. 

  968.     Num=aPage.StdPg;
    969. 

  969.     if (Num!=0) {
    970. 

  970.       rInp.Seek(nStdPos);
    971. 

  971.       while(Num>1 && aPage.Next!=0L && !rInp.GetError()) { // Standardseite suchen
    972. 

  972.         rInp>>aPage;
    973. 

  973.         if (aPage.nList!=0) SkipObjkList(rInp);
    974. 

  974.         Num--;
    975. 

  975.       }
    976. 

  976.       rInp>>aPage;
    977. 

  977.       if(Num==1 && aPage.nList!=0L) DrawObjkList( rInp,*pOutDev );
    978. 

  978.       rInp.Seek(nZchPos);
    979. 

  979.       nZchPos=rInp.Tell();
    980. 

  980.       rInp>>aPage;
    981. 

  981.     }
    982. 

  982.     if (aPage.nList!=0L) DrawObjkList(rInp,*pOutDev );
    983. 

  983. 

  984.     rMtf.Stop();
    985. 

  985.     rMtf.WindStart();
    986. 

  986.     MapMode aMap(MAP_10TH_MM,Point(),Fraction(1,4),Fraction(1,4));
    987. 

  987.     rMtf.SetPrefMapMode(aMap);
    988. 

  988.     rMtf.SetPrefSize(Size((INT16)aPage.Paper.Size.x,(INT16)aPage.Paper.Size.y));
    989. 

  989.     bRet=TRUE;
    990. 

  990.     return bRet;
    991. 

  991. }
    992. 

  992. 

  993. 

  994. 

  995. /*************************************************************************
    996. 

  996. |*
    997. 

  997. |*    SgfSDrwFilter()
    998. 

  998. |*
    999. 

  999. *************************************************************************/
    1000. 

  1000. BOOL SgfSDrwFilter(SvStream& rInp, GDIMetaFile& rMtf, INetURLObject aIniPath )
    1001. 

  1001. {
    1002. 

  1002. #if OSL_DEBUG_LEVEL > 1 // Recordgroessen checken. Neuer Compiler hat vielleichte anderes Alignment!
    1003. 

  1003.     if (sizeof(ObjTextType)!=ObjTextTypeSize)  return FALSE;
    1004. 

  1004. #endif
    1005. 

  1005. 

  1006.     ULONG     nFileStart;            // Offset des SgfHeaders. Im allgemeinen 0.
    1007. 

  1007.     SgfHeader aHead;
    1008. 

  1008.     SgfEntry  aEntr;
    1009. 

  1009.     ULONG     nNext;
    1010. 

  1010.     BOOL      bRdFlag=FALSE;         // Grafikentry gelesen ?
    1011. 

  1011.     BOOL      bRet=FALSE;            // Returncode
    1012. 

  1012. 

  1013.     aIniPath.Append( String::CreateFromAscii( "sgf.ini", 7 ) );
    1014. 

  1014. //  aIniPath.ToAbs();
    1015. 

  1015. 

  1016.     pSgfFonts = new SgfFontLst;
    1017. 

  1017. 

  1018.     pSgfFonts->AssignFN( aIniPath.GetMainURL( INetURLObject::NO_DECODE ) );
    1019. 

  1019.     nFileStart=rInp.Tell();
    1020. 

  1020.     rInp>>aHead;
    1021. 

  1021.     if (aHead.ChkMagic() && aHead.Typ==SgfStarDraw && aHead.Version==SGV_VERSION) {
    1022. 

  1022.         nNext=aHead.GetOffset();
    1023. 

  1023.         while (nNext && !bRdFlag && !rInp.GetError()) {
    1024. 

  1024.             rInp.Seek(nFileStart+nNext);
    1025. 

  1025.             rInp>>aEntr;
    1026. 

  1026.             nNext=aEntr.GetOffset();
    1027. 

  1027.             if (aEntr.Typ==aHead.Typ) {
    1028. 

  1028.                 bRet=SgfFilterSDrw( rInp,aHead,aEntr,rMtf );
    1029. 

  1029.             }
    1030. 

  1030.         } // while(nNext)
    1031. 

  1031.         if (bRdFlag) {
    1032. 

  1032.             if (!rInp.GetError()) bRet=TRUE;  // Scheinbar Ok
    1033. 

  1033.         }
    1034. 

  1034.     }
    1035. 

  1035.     delete pSgfFonts;
    1036. 

  1036.     return(bRet);
    1037. 

  1037. }
    1038. 

  1038. 

  1039. /*
    1040. 

  1040. Bitmap Dither(BYTE Intens)
    1041. 

  1041. {
    1042. 

  1042.     Bitmap aBmp;
    1043. 

  1043.     BmpInfoHeader Info;
    1044. 

    1045. 

    1046. 

  1046. const dmatrix: array[0..7,0..7] of byte =
    1047. 

  1047.         ((  0, 48, 12, 60,  3, 51, 15, 63 ),
    1048. 

  1048.          ( 32, 16, 44, 28, 35, 19, 47, 31 ),
    1049. 

  1049.          (  8, 56,  4, 52, 11, 59,  7, 55 ),
    1050. 

  1050.          ( 40, 24, 36, 20, 43, 27, 39, 23 ),
    1051. 

  1051.          (  2, 50, 14, 62,  1, 49, 13, 61 ),
    1052. 

  1052.          ( 34, 18, 46, 30, 33, 17, 45, 29 ),
    1053. 

  1053.          ( 10, 58,  6, 54,  9, 57,  5, 53 ),
    1054. 

  1054.          ( 42, 26, 38, 22, 41, 25, 37, 21 ));
    1055. 

    1056. 

    1057. 

  1057.     cmatrix: array[0..7,0..7] of byte;
    1058. 

  1058.     dmatrixn,dmatrixi: array[0..7] of byte;
    1059. 

    1060. 

    1061. 

  1061. procedure SetColorIntens(col0,col1,bal: integer);
    1062. 

  1062. var cmatrix0: array[0..63] of byte absolute cmatrix;
    1063. 

  1063.     dmatrix0: array[0..63] of byte absolute dmatrix;
    1064. 

  1064.     n,i: integer;
    1065. 

  1065.     b,bit: byte;
    1066. 

  1066. begin
    1067. 

  1067. if col0=col1 then bal:=0;
    1068. 

  1068. if bal<=32 then
    1069. 

  1069.   begin
    1070. 

  1070.   plotcolor0:=col0 and $1F; plotcolor1:=col1 and $1F;
    1071. 

  1071.   plotbal:=bal;
    1072. 

  1072.   end
    1073. 

  1073. else
    1074. 

  1074.   begin
    1075. 

  1075.   plotcolor0:=col1 and $1F; plotcolor1:=col0 and $1F;
    1076. 

  1076.   plotbal:=64-bal;
    1077. 

  1077.   end;
    1078. 

  1078. for n:=0 to 63 do
    1079. 

  1079.  if plotbal<=dmatrix0[n] then cmatrix0[n]:=col0 else cmatrix0[n]:=col1;
    1080. 

  1080. end;
    1081. 

  1081. */
    1082. 

  1082. 

  1083. #if defined( WIN ) && defined( MSC )
    1084. 

  1084. #pragma code_seg( "svtools", "AUTO_CODE" )
    1085. 

  1085. #endif
    1086. 

  1086. 

  1087. }
    1088. 

  1088. 

  1089. /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
    1090. 

  1090.