xref: /aoo41x/main/svtools/source/filter/sgvmain.cxx (revision c82f2877)

/**************************************************************
 *
 * 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.hxx>
#include <osl/endian.h>
#include <vcl/graph.hxx>
#include <tools/poly.hxx>
#include <svtools/filter.hxx>
#include "sgffilt.hxx"
#include "sgfbram.hxx"
#include "sgvmain.hxx"
#include "sgvspln.hxx"
#include <unotools/ucbstreamhelper.hxx>

//#if OSL_DEBUG_LEVEL > 1
//#include "Debug.c"
//#endif

#define SWAPPOINT(p) {  \
    p.x=SWAPSHORT(p.x); \
    p.y=SWAPSHORT(p.y); }

#define SWAPPAGE(p) {                         \
    p.Next   =SWAPLONG (p.Next   );           \
    p.nList  =SWAPLONG (p.nList  );           \
    p.ListEnd=SWAPLONG (p.ListEnd);           \
    p.Paper.Size.x=SWAPSHORT(p.Paper.Size.x); \
    p.Paper.Size.y=SWAPSHORT(p.Paper.Size.y); \
    p.Paper.RandL =SWAPSHORT(p.Paper.RandL ); \
    p.Paper.RandR =SWAPSHORT(p.Paper.RandR ); \
    p.Paper.RandO =SWAPSHORT(p.Paper.RandO ); \
    p.Paper.RandU =SWAPSHORT(p.Paper.RandU ); \
    SWAPPOINT(p.U);                           \
    sal_uInt16 iTemp;                             \
    for (iTemp=0;iTemp<20;iTemp++) {          \
        rPage.HlpLnH[iTemp]=SWAPSHORT(rPage.HlpLnH[iTemp]);       \
        rPage.HlpLnV[iTemp]=SWAPSHORT(rPage.HlpLnV[iTemp]);      }}

#define SWAPOBJK(o) {                 \
    o.Last    =SWAPLONG (o.Last    ); \
    o.Next    =SWAPLONG (o.Next    ); \
    o.MemSize =SWAPSHORT(o.MemSize ); \
    SWAPPOINT(o.ObjMin);              \
    SWAPPOINT(o.ObjMax);              }

#define SWAPLINE(l) {             \
    l.LMSize=SWAPSHORT(l.LMSize); \
    l.LDicke=SWAPSHORT(l.LDicke); }

#define SWAPAREA(a) {               \
    a.FDummy2=SWAPSHORT(a.FDummy2); \
    a.FMuster=SWAPSHORT(a.FMuster); }

#define SWAPTEXT(t) {               \
    SWAPLINE(t.L);                  \
    SWAPAREA(t.F);                  \
    t.FontLo =SWAPSHORT(t.FontLo ); \
    t.FontHi =SWAPSHORT(t.FontHi ); \
    t.Grad   =SWAPSHORT(t.Grad   ); \
    t.Breite =SWAPSHORT(t.Breite ); \
    t.Schnitt=SWAPSHORT(t.Schnitt); \
    t.LnFeed =SWAPSHORT(t.LnFeed ); \
    t.Slant  =SWAPSHORT(t.Slant  ); \
    SWAPLINE(t.ShdL);               \
    SWAPAREA(t.ShdF);               \
    SWAPPOINT(t.ShdVers);           \
    SWAPAREA(t.BackF);              }


////////////////////////////////////////////////////////////////////////////////////////////////////
//
//  Einschraenkungen:
//
//  - Flaechenmuster werden den unter StarView verfuegbaren Mustern angenaehert.
//  - Linienenden werden unter StarView immer rund dargestellt und gehen ueber
//    den Endpunkt der Linie hinaus.
//  - Linienmuster werden den unter StarView verfuegbaren Mustern angenaehert.
//    Transparent/Opak wird zur Zeit noch nicht beruecksichtigt.
//  - Keine gedrehten Ellipsen
//
//
//
//
////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////
// Fuer Fontuebersetzung ///////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
SgfFontLst* pSgfFonts = 0;

////////////////////////////////////////////////////////////////////////////////////////////////////
// Fuer Kreisunterarten, Text und gedrehte Rechtecke ///////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////
void RotatePoint(PointType& P, sal_Int16 cx, sal_Int16 cy, double sn, double cs)
{
	sal_Int16  dx,dy;
	double x1,y1;
	dx=P.x-cx;
	dy=P.y-cy;
	x1=dx*cs-dy*sn;
	y1=dy*cs+dx*sn;
	P.x=cx+sal_Int16(x1);
	P.y=cy+sal_Int16(y1);
}

void RotatePoint(Point& P, sal_Int16 cx, sal_Int16 cy, double sn, double cs)
{
	sal_Int16  dx,dy;
	double x1,y1;
	dx=(sal_Int16)(P.X()-cx);
	dy=(sal_Int16)(P.Y()-cy);
	x1=dx*cs-dy*sn;
	y1=dy*cs+dx*sn;
	P=Point(cx+sal_Int16(x1),cy+sal_Int16(y1));
}

sal_Int16 iMulDiv(sal_Int16 a, sal_Int16 Mul, sal_Int16 Div)
{
	sal_Int32 Temp;
	Temp=sal_Int32(a)*sal_Int32(Mul)/sal_Int32(Div);
	return sal_Int16(Temp);
}

sal_uInt16 MulDiv(sal_uInt16 a, sal_uInt16 Mul, sal_uInt16 Div)
{
	sal_uInt32 Temp;
	Temp=sal_uInt32(a)*sal_uInt32(Mul)/sal_uInt32(Div);
	return sal_uInt16(Temp);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
// SgfFilterSDrw ///////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////

SvStream& operator>>(SvStream& rIStream, DtHdType& rDtHd)
{
	rIStream.Read((char*)&rDtHd.Reserved[0],DtHdSize);
	return rIStream;
}

void DtHdOverSeek(SvStream& rInp)
{
	sal_uLong FPos=rInp.Tell();
	FPos+=(sal_uLong)DtHdSize;
	rInp.Seek(FPos);
//    rInp.seekg(rInp.tellg()+(sal_uLong)DtHdSize);
}


SvStream& operator>>(SvStream& rIStream, PageType& rPage)
{
	rIStream.Read((char*)&rPage.Next,PageSize);
#if defined OSL_BIGENDIAN
	SWAPPAGE(rPage);
#endif
	return rIStream;
}

void ObjkOverSeek(SvStream& rInp, ObjkType& rObjk)
{
	sal_uLong Siz;
	Siz=(sal_uLong)rObjk.MemSize+rObjk.Last;  // ObjSize+ObjAnhSize
	rInp.Seek(rInp.Tell()+Siz);
}

SvStream& operator>>(SvStream& rInp, ObjkType& rObjk)
{   // Die Fileposition im Stream bleibt unveraendert!
	sal_uLong nPos;
	nPos=rInp.Tell();
	rInp.Read((char*)&rObjk.Last,ObjkSize);
#if defined OSL_BIGENDIAN
	SWAPOBJK(rObjk);
#endif
#ifdef InArbeit
	sal_uLong nPos1=rInp.Tell();
	if(nPos == nPos1) InfoBox( NULL, "tellg funkt nich" ).Execute();
#endif
	rInp.Seek(nPos);
#ifdef InArbeit
	if (rInp.Tell() != nPos) InfoBox( NULL, "seekg funkt nich" ).Execute();
#endif
	return rInp;
}
SvStream& operator>>(SvStream& rInp, StrkType& rStrk)
{
	rInp.Read((char*)&rStrk.Last,StrkSize);
#if defined OSL_BIGENDIAN
	SWAPOBJK (rStrk);
	SWAPLINE (rStrk.L);
	SWAPPOINT(rStrk.Pos1);
	SWAPPOINT(rStrk.Pos2);
#endif
	return rInp;
}
SvStream& operator>>(SvStream& rInp, RectType& rRect)
{
	rInp.Read((char*)&rRect.Last,RectSize);
#if defined OSL_BIGENDIAN
	SWAPOBJK (rRect);
	SWAPLINE (rRect.L);
	SWAPAREA (rRect.F);
	SWAPPOINT(rRect.Pos1);
	SWAPPOINT(rRect.Pos2);
	rRect.Radius  =SWAPSHORT(rRect.Radius  );
	rRect.DrehWink=SWAPSHORT(rRect.DrehWink);
	rRect.Slant   =SWAPSHORT(rRect.Slant   );
#endif
	return rInp;
}
SvStream& operator>>(SvStream& rInp, PolyType& rPoly)
{
	rInp.Read((char*)&rPoly.Last,PolySize);
#if defined OSL_BIGENDIAN
	SWAPOBJK (rPoly);
	SWAPLINE (rPoly.L);
	SWAPAREA (rPoly.F);
	// rPoly.EckP=SWAPLONG(rPoly.EckP);
#endif
	return rInp;
}
SvStream& operator>>(SvStream& rInp, SplnType& rSpln)
{
	rInp.Read((char*)&rSpln.Last,SplnSize);
#if defined OSL_BIGENDIAN
	SWAPOBJK (rSpln);
	SWAPLINE (rSpln.L);
	SWAPAREA (rSpln.F);
	// rSpln.EckP=SWAPLONG(rSpln.EckP);
#endif
	return rInp;
}
SvStream& operator>>(SvStream& rInp, CircType& rCirc)
{
	rInp.Read((char*)&rCirc.Last,CircSize);
#if defined OSL_BIGENDIAN
	SWAPOBJK (rCirc);
	SWAPLINE (rCirc.L);
	SWAPAREA (rCirc.F);
	SWAPPOINT(rCirc.Radius);
	SWAPPOINT(rCirc.Center);
	rCirc.DrehWink =SWAPSHORT(rCirc.DrehWink );
	rCirc.StartWink=SWAPSHORT(rCirc.StartWink);
	rCirc.RelWink  =SWAPSHORT(rCirc.RelWink  );
#endif
	return rInp;
}
SvStream& operator>>(SvStream& rInp, TextType& rText)
{
	rInp.Read((char*)&rText.Last,TextSize);
#if defined OSL_BIGENDIAN
	SWAPOBJK (rText);
	SWAPTEXT (rText.T);
	SWAPPOINT(rText.Pos1);
	SWAPPOINT(rText.Pos2);
	rText.TopOfs  =SWAPSHORT(rText.TopOfs  );
	rText.DrehWink=SWAPSHORT(rText.DrehWink);
	rText.BoxSlant=SWAPSHORT(rText.BoxSlant);
	rText.BufSize =SWAPSHORT(rText.BufSize );
	//rText.Buf     =SWAPLONG (rText.Buf     );
	//rText.Ext     =SWAPLONG (rText.Ext     );
	SWAPPOINT(rText.FitSize);
	rText.FitBreit=SWAPSHORT(rText.FitBreit);
#endif
	rText.Buffer=NULL;
	return rInp;
}
SvStream& operator>>(SvStream& rInp, BmapType& rBmap)
{
	rInp.Read((char*)&rBmap.Last,BmapSize);
#if defined OSL_BIGENDIAN
	SWAPOBJK (rBmap);
	SWAPAREA (rBmap.F);
	SWAPPOINT(rBmap.Pos1);
	SWAPPOINT(rBmap.Pos2);
	rBmap.DrehWink=SWAPSHORT(rBmap.DrehWink);
	rBmap.Slant   =SWAPSHORT(rBmap.Slant   );
	SWAPPOINT(rBmap.PixSize);
#endif
	return rInp;
}
SvStream& operator>>(SvStream& rInp, GrupType& rGrup)
{
	rInp.Read((char*)&rGrup.Last,GrupSize);
#if defined OSL_BIGENDIAN
	SWAPOBJK (rGrup);
	rGrup.SbLo     =SWAPSHORT(rGrup.SbLo     );
	rGrup.SbHi     =SWAPSHORT(rGrup.SbHi     );
	rGrup.UpLo     =SWAPSHORT(rGrup.UpLo     );
	rGrup.UpHi     =SWAPSHORT(rGrup.UpHi     );
	rGrup.ChartSize=SWAPSHORT(rGrup.ChartSize);
	rGrup.ChartPtr =SWAPLONG (rGrup.ChartPtr );
#endif
	return rInp;
}



/*************************************************************************
|*
|*    Sgv2SvFarbe()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
Color Sgv2SvFarbe(sal_uInt8 nFrb1, sal_uInt8 nFrb2, sal_uInt8 nInts)
{
	sal_uInt16 r1=0,g1=0,b1=0,r2=0,g2=0,b2=0;
	sal_uInt8   nInt2=100-nInts;
	switch(nFrb1 & 0x07) {
		case 0:  r1=0xFF; g1=0xFF; b1=0xFF; break;
		case 1:  r1=0xFF; g1=0xFF;            break;
		case 2:           g1=0xFF; b1=0xFF; break;
		case 3:           g1=0xFF;            break;
		case 4:  r1=0xFF;          b1=0xFF; break;
		case 5:  r1=0xFF;                       break;
		case 6:                    b1=0xFF; break;
		case 7:                                   break;
	}
	switch(nFrb2 & 0x07) {
		case 0:  r2=0xFF; g2=0xFF; b2=0xFF; break;
		case 1:  r2=0xFF; g2=0xFF;            break;
		case 2:           g2=0xFF; b2=0xFF; break;
		case 3:           g2=0xFF;            break;
		case 4:  r2=0xFF;          b2=0xFF; break;
		case 5:  r2=0xFF;                       break;
		case 6:                    b2=0xFF; break;
		case 7:                                   break;
	}
	r1=(sal_uInt16)((sal_uInt32)r1*nInts/100+(sal_uInt32)r2*nInt2/100);
	g1=(sal_uInt16)((sal_uInt32)g1*nInts/100+(sal_uInt32)g2*nInt2/100);
	b1=(sal_uInt16)((sal_uInt32)b1*nInts/100+(sal_uInt32)b2*nInt2/100);
	Color aColor( (sal_uInt8)r1, (sal_uInt8)g1, (sal_uInt8)b1 );
	return aColor;
}

void SetLine(ObjLineType& rLine, OutputDevice& rOut)
{
/* !!!
	PenStyle aStyle=PEN_SOLID;
	switch(rLine.LMuster & 0x07) {
		case 0: aStyle=PEN_NULL;    break;
		case 1: aStyle=PEN_SOLID;   break;
        case 2: aStyle=PEN_DOT;     break;    // . . . . . . . . . . . . . .
        case 3: aStyle=PEN_DASH;    break;    // __ __ __ __ __ __ __ __ __
        case 4: aStyle=PEN_DASH;    break;    // ___ ___ ___ ___ ___ ___ ___
        case 5: aStyle=PEN_DASHDOT; break;    // __ . __ . __ . __ . __ . __
        case 6: aStyle=PEN_DASHDOT; break;    // __ _ __ _ __ _ __ _ __ _ __
        case 7: aStyle=PEN_DASHDOT; break;    // ___ _ _ ___ _ _ ___ _ _ ___
	}
	Pen aPen(Sgv2SvFarbe(rLine.LFarbe,rLine.LBFarbe,rLine.LIntens),rLine.LDicke,aStyle);
	SetPen(aPen,rOut);
*/
	if( 0 == ( rLine.LMuster & 0x07 ) )
		rOut.SetLineColor();
	else
		rOut.SetLineColor( Sgv2SvFarbe(rLine.LFarbe,rLine.LBFarbe,rLine.LIntens) );
}

void SetArea(ObjAreaType& rArea, OutputDevice& rOut)
{
/*
	BrushStyle aStyle=BRUSH_SOLID;
	switch(rArea.FMuster & 0x00FF) {
		case  0: aStyle=BRUSH_NULL;      break;
		case  1: aStyle=BRUSH_SOLID;     break;
		case  2: case  4: case  6: case  8:
		case 10: case 12: case 14: case 16:
		case 43: case 45:                   aStyle=BRUSH_VERT;      break;
		case  3: case  5: case  7: case  9:
		case 11: case 13: case 15: case 17:
		case 42: case 44:                   aStyle=BRUSH_HORZ;      break;
		case 18: case 20: case 22: case 24:
		case 26: case 28: case 30: case 32:
		case 46: case 48:                   aStyle=BRUSH_UPDIAG;    break;
		case 19: case 21: case 23: case 25:
		case 27: case 29: case 31: case 33:
		case 47: case 49:                   aStyle=BRUSH_DOWNDIAG;  break;
		case 34: case 35: case 36: case 37: aStyle=BRUSH_CROSS;     break;
		case 38: case 39: case 40: case 41: aStyle=BRUSH_DIAGCROSS; break;
		default: aStyle=BRUSH_DIAGCROSS; break;
	}
	Brush aBrush(Sgv2SvFarbe(rArea.FFarbe,rArea.FBFarbe,rArea.FIntens),aStyle);
	aBrush.SetTransparent((rArea.FMuster & 0x80) !=0L);
	SetBrush(aBrush,rOut);
*/
	if( 0 == ( rArea.FMuster & 0x00FF ) )
		rOut.SetFillColor();
	else
		rOut.SetFillColor( Sgv2SvFarbe( rArea.FFarbe,rArea.FBFarbe,rArea.FIntens ) );
}

/*************************************************************************
|*
|*    ObjkType::DrawObjekt()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
void ObjkType::Draw(OutputDevice&)
{
//    ShowSDObjk(*this);
}

void Obj0Type::Draw(OutputDevice&) {}

/*************************************************************************
|*
|*    StrkType::DrawObjekt()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
void StrkType::Draw(OutputDevice& rOut)
{
	SetLine(L,rOut);
	rOut.DrawLine(Point(Pos1.x,Pos1.y),Point(Pos2.x,Pos2.y)); // !!!
}

/*************************************************************************
|*
|*    RectType::DrawObjekt()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
void SgfAreaColorIntens(sal_uInt16 Muster, sal_uInt8 Col1, sal_uInt8 Col2, sal_uInt8 Int, OutputDevice& rOut)
{
	ObjAreaType F;
	F.FMuster=Muster;
	F.FFarbe=Col2;
	F.FBFarbe=Col1;
	F.FIntens=Int;
	SetArea(F,rOut);
}

void DrawSlideRect(sal_Int16 x1, sal_Int16 y1, sal_Int16 x2, sal_Int16 y2, ObjAreaType& F, OutputDevice& rOut)
{
	sal_Int16 i,i0,b,b0;
	sal_Int16 Int1,Int2;
	sal_Int16 Col1,Col2;
	//     ClipMerk: HgdClipRec;
	sal_Int16 cx,cy;
	sal_Int16 MaxR;
	sal_Int32 dx,dy;

	rOut.SetLineColor();
	if (x1>x2) { i=x1; x1=x2; x2=i; }
	if (y1>y2) { i=y1; y1=y2; y2=i; }
	Col1=F.FBFarbe & 0x87; Col2=F.FFarbe & 0x87;
	Int1=100-F.FIntens; Int2=F.FIntens;
	if (Int1==Int2) {
		SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)Int2,rOut);
		rOut.DrawRect(Rectangle(x1,y1,x2,y2));
	} else {
		b0=Int1;
		switch (F.FBFarbe & 0x38) {
			case 0x08: { // vertikal
				i0=y1;
				i=y1;
				while (i<=y2) {
					b=Int1+sal_Int16((sal_Int32)(Int2-Int1)*(sal_Int32)(i-y1) /(sal_Int32)(y2-y1+1));
					if (b!=b0) {
						SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)b0,rOut);
						rOut.DrawRect(Rectangle(x1,i0,x2,i-1));
						i0=i; b0=b;
					}
					i++;
				}
				SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)Int2,rOut);
				rOut.DrawRect(Rectangle(x1,i0,x2,y2));
			} break;
			case 0x28: { // horizontal
				i0=x1;
				i=x1;
				while (i<=x2) {
					b=Int1+sal_Int16((sal_Int32)(Int2-Int1)*(sal_Int32)(i-x1) /(sal_Int32)(x2-x1+1));
					if (b!=b0) {
						SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)b0,rOut);
						rOut.DrawRect(Rectangle(i0,y1,i-1,y2));
						i0=i; b0=b;
					}
					i++;
				}
				SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)Int2,rOut);
				rOut.DrawRect(Rectangle(i0,y1,x2,y2));
			} break;

			case 0x18: case 0x38: { // Kreis
				Region ClipMerk=rOut.GetClipRegion();
				double a;

				rOut.SetClipRegion(Region(Rectangle(x1,y1,x2,y2)));
				cx=(x1+x2) /2;
				cy=(y1+y2) /2;
				dx=x2-x1+1;
				dy=y2-y1+1;
				a=sqrt((double)(dx*dx+dy*dy));
				MaxR=sal_Int16(a) /2 +1;
				b0=Int2;
				i0=MaxR; if (MaxR<1) MaxR=1;
				i=MaxR;
				while (i>=0) {
					b=Int1+sal_Int16((sal_Int32(Int2-Int1)*sal_Int32(i)) /sal_Int32(MaxR));
					if (b!=b0) {
						SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)b0,rOut);
						//if (i0>200 || (Col1 & $80)!=0 || (Col2 & $80)!=0) {
                        //  then begin { Fallunterscheidung fuer etwas bessere Performance }
						//    s2:=i0-i+2;
						//    SetPenSize(s2);
						//    s2:=s2 div 2;
						//    Circle(cx,cy,i0-s2,i0-s2);{}
						//  else
						rOut.DrawEllipse(Rectangle(cx-i0,cy-i0,cx+i0,cy+i0));
						i0=i; b0=b;
					}
					i--;
				}
				SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)Int1,rOut);
				rOut.DrawEllipse(Rectangle(cx-i0,cy-i0,cx+i0,cy+i0));
				rOut.SetClipRegion(ClipMerk);
			} break; // Kreis
		}
	}
}


void RectType::Draw(OutputDevice& rOut)
{
	if (L.LMuster!=0) L.LMuster=1; // keine Linienmuster hier, nur an oder aus
	SetArea(F,rOut);
	if (DrehWink==0) {
	if ((F.FBFarbe & 0x38)==0 || Radius!=0) {
			SetLine(L,rOut);
			rOut.DrawRect(Rectangle(Pos1.x,Pos1.y,Pos2.x,Pos2.y),Radius,Radius);
		} else {
			DrawSlideRect(Pos1.x,Pos1.y,Pos2.x,Pos2.y,F,rOut);
			if (L.LMuster!=0) {
				SetLine(L,rOut);
				rOut.SetFillColor();
				rOut.DrawRect(Rectangle(Pos1.x,Pos1.y,Pos2.x,Pos2.y));
			}
		}
	} else {
		Point  aPts[4];
		sal_uInt16 i;
		double sn,cs;
		sn=sin(double(DrehWink)*3.14159265359/18000);
		cs=cos(double(DrehWink)*3.14159265359/18000);
		aPts[0]=Point(Pos1.x,Pos1.y);
		aPts[1]=Point(Pos2.x,Pos1.y);
		aPts[2]=Point(Pos2.x,Pos2.y);
		aPts[3]=Point(Pos1.x,Pos2.y);
		for (i=0;i<4;i++) {
			RotatePoint(aPts[i],Pos1.x,Pos1.y,sn,cs);
		}
		SetLine(L,rOut);
		Polygon aPoly(4,aPts);
		rOut.DrawPolygon(aPoly);
	}
}

/*************************************************************************
|*
|*    PolyType::Draw()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
void PolyType::Draw(OutputDevice& rOut)
{
	if ((Flags & PolyClosBit) !=0) SetArea(F,rOut);
	SetLine(L,rOut);
	Polygon aPoly(nPoints);
	sal_uInt16 i;
	for(i=0;i<nPoints;i++) aPoly.SetPoint(Point(EckP[i].x,EckP[i].y),i);
	if ((Flags & PolyClosBit) !=0) {
		rOut.DrawPolygon(aPoly);
	} else {
		rOut.DrawPolyLine(aPoly);
	}
}

/*************************************************************************
|*
|*    SplnType::Draw()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
void SplnType::Draw(OutputDevice& rOut)
{
	if ((Flags & PolyClosBit) !=0) SetArea(F,rOut);
	SetLine(L,rOut);
	Polygon aPoly(0);
	Polygon aSpln(nPoints);
	sal_uInt16 i;
	for(i=0;i<nPoints;i++) aSpln.SetPoint(Point(EckP[i].x,EckP[i].y),i);
	if ((Flags & PolyClosBit) !=0) {
		Spline2Poly(aSpln,sal_True,aPoly);
		if (aPoly.GetSize()>0) rOut.DrawPolygon(aPoly);
	} else {
		Spline2Poly(aSpln,sal_False,aPoly);
		if (aPoly.GetSize()>0) rOut.DrawPolyLine(aPoly);
	}
}

/*************************************************************************
|*
|*    CircType::Draw()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
void DrawSlideCirc(sal_Int16 cx, sal_Int16 cy, sal_Int16 rx, sal_Int16 ry, ObjAreaType& F, OutputDevice& rOut)
{
	sal_Int16 x1=cx-rx;
	sal_Int16 y1=cy-ry;
	sal_Int16 x2=cx+rx;
	sal_Int16 y2=cy+ry;

	sal_Int16 i,i0,b,b0;
	sal_Int16 Int1,Int2;
	sal_Int16 Col1,Col2;

	rOut.SetLineColor();
	Col1=F.FBFarbe & 0x87; Col2=F.FFarbe & 0x87;
	Int1=100-F.FIntens; Int2=F.FIntens;
	if (Int1==Int2) {
		SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)Int2,rOut);
		rOut.DrawEllipse(Rectangle(x1,y1,x2,y2));
	} else {
		b0=Int1;
		switch (F.FBFarbe & 0x38) {
			case 0x08: { // vertikal
				Region ClipMerk=rOut.GetClipRegion();
				i0=y1;
				i=y1;
				while (i<=y2) {
					b=Int1+sal_Int16((sal_Int32)(Int2-Int1)*(sal_Int32)(i-y1) /(sal_Int32)(y2-y1+1));
					if (b!=b0) {
						SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)b0,rOut);
						rOut.SetClipRegion(Rectangle(x1,i0,x2,i-1));
						rOut.DrawEllipse(Rectangle(x1,y1,x2,y2));
						i0=i; b0=b;
					}
					i++;
				}
				SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)Int2,rOut);
				rOut.SetClipRegion(Rectangle(x1,i0,x2,y2));
				rOut.DrawEllipse(Rectangle(x1,y1,x2,y2));
				rOut.SetClipRegion(ClipMerk);
			} break;
			case 0x28: { // horizontal
				Region ClipMerk=rOut.GetClipRegion();
				i0=x1;
				i=x1;
				while (i<=x2) {
					b=Int1+sal_Int16((sal_Int32)(Int2-Int1)*(sal_Int32)(i-x1) /(sal_Int32)(x2-x1+1));
					if (b!=b0) {
						SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)b0,rOut);
						rOut.SetClipRegion(Rectangle(i0,y1,i-1,y2));
						rOut.DrawEllipse(Rectangle(x1,y1,x2,y2));
						i0=i; b0=b;
					}
					i++;
				}
				SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)Int2,rOut);
				rOut.SetClipRegion(Rectangle(i0,y1,x2,y2));
				rOut.DrawEllipse(Rectangle(x1,y1,x2,y2));
				rOut.SetClipRegion(ClipMerk);
			} break;

			case 0x18: case 0x38: { // Kreis
				sal_Int16 MaxR;

				if (rx<1) rx=1;
				if (ry<1) ry=1;
				MaxR=rx;
				b0=Int2;
				i0=MaxR; if (MaxR<1) MaxR=1;
				i=MaxR;
				while (i>=0) {
					b=Int1+sal_Int16((sal_Int32(Int2-Int1)*sal_Int32(i)) /sal_Int32(MaxR));
					if (b!=b0) {
						sal_Int32 temp=sal_Int32(i0)*sal_Int32(ry)/sal_Int32(rx);
						sal_Int16 j0=sal_Int16(temp);
						SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)b0,rOut);
						rOut.DrawEllipse(Rectangle(cx-i0,cy-j0,cx+i0,cy+j0));
						i0=i; b0=b;
					}
					i--;
				}
				SgfAreaColorIntens(F.FMuster,(sal_uInt8)Col1,(sal_uInt8)Col2,(sal_uInt8)Int1,rOut);
				rOut.DrawEllipse(Rectangle(cx-i0,cy-i0,cx+i0,cy+i0));
			} break; // Kreis
		}
	}
}


void CircType::Draw(OutputDevice& rOut)
{
	Rectangle aRect(Center.x-Radius.x,Center.y-Radius.y,Center.x+Radius.x,Center.y+Radius.y);

	if (L.LMuster!=0) L.LMuster=1; // keine Linienmuster hier, nur an oder aus
	SetArea(F,rOut);
	if ((Flags & 0x03)==CircFull) {
		if ((F.FBFarbe & 0x38)==0) {
			SetLine(L,rOut);
			rOut.DrawEllipse(aRect);
		} else {
			DrawSlideCirc(Center.x,Center.y,Radius.x,Radius.y,F,rOut);
			if (L.LMuster!=0) {
				SetLine(L,rOut);
				rOut.SetFillColor();
				rOut.DrawEllipse(aRect);
			}
		}
	} else {
		PointType a,b;
		Point  aStrt,aEnde;
		double sn,cs;

		a.x=Center.x+Radius.x; a.y=Center.y; b=a;
		sn=sin(double(StartWink)*3.14159265359/18000);
		cs=cos(double(StartWink)*3.14159265359/18000);
		RotatePoint(a,Center.x,Center.y,sn,cs);
		sn=sin(double(StartWink+RelWink)*3.14159265359/18000);
		cs=cos(double(StartWink+RelWink)*3.14159265359/18000);
		RotatePoint(b,Center.x,Center.y,sn,cs);
		if (Radius.x!=Radius.y) {
		  if (Radius.x<1) Radius.x=1;
		  if (Radius.y<1) Radius.y=1;
		  a.y = a.y - Center.y;
		  b.y = b.y - Center.y;
		  a.y=iMulDiv(a.y,Radius.y,Radius.x);
		  b.y=iMulDiv(b.y,Radius.y,Radius.x);
		  a.y = a.y + Center.y;
		  b.y = b.y + Center.y;
		}
		aStrt=Point(a.x,a.y);
		aEnde=Point(b.x,b.y);
		SetLine(L,rOut);
		switch (Flags & 0x03) {
			case CircArc : rOut.DrawArc(aRect,aEnde,aStrt); break;
			case CircSect:
			case CircAbsn: rOut.DrawPie(aRect,aEnde,aStrt); break;
		}
	}
}

/*************************************************************************
|*
|*    BmapType::Draw()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/

void BmapType::Draw(OutputDevice& rOut)
{
	//ifstream aInp;
	unsigned char	nSgfTyp;
	sal_uInt16			nVersion;
	String			aStr(
        reinterpret_cast< char const * >(&Filename[ 1 ]),
        (xub_StrLen)Filename[ 0 ], RTL_TEXTENCODING_UTF8 );
	INetURLObject	aFNam( aStr );

	SvStream* pInp = ::utl::UcbStreamHelper::CreateStream( aFNam.GetMainURL( INetURLObject::NO_DECODE ), STREAM_READ );
	if ( pInp )
	{
		nSgfTyp=CheckSgfTyp( *pInp,nVersion);
		switch(nSgfTyp) {
			case SGF_BITIMAGE: {
				GraphicFilter aFlt;
				Graphic aGrf;
				sal_uInt16 nRet;
				nRet=aFlt.ImportGraphic(aGrf,aFNam);
				aGrf.Draw(&rOut,Point(Pos1.x,Pos1.y),Size(Pos2.x-Pos1.x,Pos2.y-Pos1.y));
			} break;
			case SGF_SIMPVECT: {
				GDIMetaFile aMtf;
				SgfVectXofs=Pos1.x;
				SgfVectYofs=Pos1.y;
				SgfVectXmul=Pos2.x-Pos1.x;
				SgfVectYmul=Pos2.y-Pos1.y;
				SgfVectXdiv=0;
				SgfVectYdiv=0;
				SgfVectScal=sal_True;
				SgfVectFilter(*pInp,aMtf);
				SgfVectXofs=0;
				SgfVectYofs=0;
				SgfVectXmul=0;
				SgfVectYmul=0;
				SgfVectXdiv=0;
				SgfVectYdiv=0;
				SgfVectScal=sal_False;
				aMtf.Play(&rOut);
			} break;
		}
		delete pInp;
	}
}


/*************************************************************************
|*
|*    GrupType::...
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
sal_uInt32 GrupType::GetSubPtr()
{
	return sal_uInt32(SbLo)+0x00010000*sal_uInt32(SbHi);
}

/*************************************************************************
|*
|*    DrawObjkList()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
void DrawObjkList( SvStream& rInp, OutputDevice& rOut )
{
	ObjkType aObjk;
	sal_uInt16 nGrpCnt=0;
	sal_Bool bEnde=sal_False;
	do {
		rInp>>aObjk;
		if (!rInp.GetError()) {
			switch(aObjk.Art) {
				case ObjStrk: { StrkType aStrk; rInp>>aStrk; if (!rInp.GetError()) aStrk.Draw(rOut); } break;
				case ObjRect: { RectType aRect; rInp>>aRect; if (!rInp.GetError()) aRect.Draw(rOut); } break;
				case ObjCirc: { CircType aCirc; rInp>>aCirc; if (!rInp.GetError()) aCirc.Draw(rOut); } break;
				case ObjText: {
					TextType aText;
					rInp>>aText;
					if (!rInp.GetError()) {
                        aText.Buffer=new UCHAR[aText.BufSize+1]; // Ein mehr fuer LookAhead bei CK-Trennung
						rInp.Read((char* )aText.Buffer,aText.BufSize);
						if (!rInp.GetError()) aText.Draw(rOut);
						delete[] aText.Buffer;
					}
				} break;
				case ObjBmap: {
					BmapType aBmap;
					rInp>>aBmap;
					if (!rInp.GetError()) {
						aBmap.Draw(rOut);
					}
				} break;
				case ObjPoly: {
					PolyType aPoly;
					rInp>>aPoly;
					if (!rInp.GetError()) {
						aPoly.EckP=new PointType[aPoly.nPoints];
						rInp.Read((char*)aPoly.EckP,4*aPoly.nPoints);
#if defined OSL_BIGENDIAN
						for(short i=0;i<aPoly.nPoints;i++) SWAPPOINT(aPoly.EckP[i]);
#endif
						if (!rInp.GetError()) aPoly.Draw(rOut);
						delete[] aPoly.EckP;
					}
				} break;
				case ObjSpln: {
					SplnType aSpln;
					rInp>>aSpln;
					if (!rInp.GetError()) {
						aSpln.EckP=new PointType[aSpln.nPoints];
						rInp.Read((char*)aSpln.EckP,4*aSpln.nPoints);
#if defined OSL_BIGENDIAN
						for(short i=0;i<aSpln.nPoints;i++) SWAPPOINT(aSpln.EckP[i]);
#endif
						if (!rInp.GetError()) aSpln.Draw(rOut);
						delete[] aSpln.EckP;
					}
				} break;
				case ObjGrup: {
					GrupType aGrup;
					rInp>>aGrup;
					if (!rInp.GetError()) {
                        rInp.Seek(rInp.Tell()+aGrup.Last); // Obj-Anhaengsel
						if(aGrup.GetSubPtr()!=0L) nGrpCnt++;// DrawObjkList(rInp,rOut );
					}
				} break;
				default: {
					aObjk.Draw(rOut);          // Objektbezeichnung auf 2. Screen
                    ObjkOverSeek(rInp,aObjk);  // zum naechsten Objekt
				}
			}
		} // if rInp
		if (!rInp.GetError()) {
			if (aObjk.Next==0L) {
				if (nGrpCnt==0) bEnde=sal_True;
				else nGrpCnt--;
			}
		} else {
			bEnde=sal_True;  // Lesefehler
		}
	} while (!bEnde);
}

/*************************************************************************
|*
|*    SkipObjkList()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
void SkipObjkList(SvStream& rInp)
{
	ObjkType aObjk;
	do
	{
		rInp>>aObjk;
		if(aObjk.Art==ObjGrup) {
			GrupType aGrup;
			rInp>>aGrup;
            rInp.Seek(rInp.Tell()+aGrup.Last); // Obj-Anhaengsel
			if(aGrup.GetSubPtr()!=0L) SkipObjkList(rInp);
		} else {
            ObjkOverSeek(rInp,aObjk);  // zum naechsten Objekt
		}
	} while (aObjk.Next!=0L && !rInp.GetError());
}

/*************************************************************************
|*
|*    SgfFilterSDrw()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
sal_Bool SgfFilterSDrw( SvStream& rInp, SgfHeader&, SgfEntry&, GDIMetaFile& rMtf )
{
	sal_Bool          bRet = sal_False;
	PageType      aPage;
	VirtualDevice aOutDev;
	OutputDevice* pOutDev;
	sal_uLong         nStdPos;
	sal_uLong         nZchPos;
	sal_uInt16        Num;

	pOutDev=&aOutDev;
	DtHdOverSeek(rInp); // DataHeader weglesen

	nStdPos=rInp.Tell();
	do {                // Standardseiten weglesen
		rInp>>aPage;
		if (aPage.nList!=0) SkipObjkList(rInp);
	} while (aPage.Next!=0L && !rInp.GetError());

//    ShowMsg("Zeichnungseite(n)\n");
	nZchPos=rInp.Tell();
	rInp>>aPage;

	rMtf.Record(pOutDev);
	Num=aPage.StdPg;
	if (Num!=0) {
	  rInp.Seek(nStdPos);
	  while(Num>1 && aPage.Next!=0L && !rInp.GetError()) { // Standardseite suchen
		rInp>>aPage;
		if (aPage.nList!=0) SkipObjkList(rInp);
		Num--;
	  }
	  rInp>>aPage;
	  if(Num==1 && aPage.nList!=0L) DrawObjkList( rInp,*pOutDev );
	  rInp.Seek(nZchPos);
	  nZchPos=rInp.Tell();
	  rInp>>aPage;
	}
	if (aPage.nList!=0L) DrawObjkList(rInp,*pOutDev );

	rMtf.Stop();
	rMtf.WindStart();
	MapMode aMap(MAP_10TH_MM,Point(),Fraction(1,4),Fraction(1,4));
	rMtf.SetPrefMapMode(aMap);
	rMtf.SetPrefSize(Size((sal_Int16)aPage.Paper.Size.x,(sal_Int16)aPage.Paper.Size.y));
	bRet=sal_True;
	return bRet;
}



/*************************************************************************
|*
|*    SgfSDrwFilter()
|*
|*    Beschreibung
|*    Ersterstellung    JOE 23.06.93
|*    Letzte Aenderung  JOE 23.06.93
|*
*************************************************************************/
sal_Bool SgfSDrwFilter(SvStream& rInp, GDIMetaFile& rMtf, INetURLObject aIniPath )
{
#if OSL_DEBUG_LEVEL > 1 // Recordgroessen checken. Neuer Compiler hat vielleichte anderes Alignment!
	if (sizeof(ObjTextType)!=ObjTextTypeSize)  return sal_False;
#endif

	sal_uLong     nFileStart;            // Offset des SgfHeaders. Im allgemeinen 0.
	SgfHeader aHead;
	SgfEntry  aEntr;
	sal_uLong     nNext;
	sal_Bool      bRdFlag=sal_False;         // Grafikentry gelesen ?
	sal_Bool      bRet=sal_False;            // Returncode

	aIniPath.Append( String::CreateFromAscii( "sgf.ini", 7 ) );
//	aIniPath.ToAbs();

	pSgfFonts = new SgfFontLst;

	pSgfFonts->AssignFN( aIniPath.GetMainURL( INetURLObject::NO_DECODE ) );
	nFileStart=rInp.Tell();
	rInp>>aHead;
	if (aHead.ChkMagic() && aHead.Typ==SgfStarDraw && aHead.Version==SGV_VERSION) {
		nNext=aHead.GetOffset();
		while (nNext && !bRdFlag && !rInp.GetError()) {
			rInp.Seek(nFileStart+nNext);
			rInp>>aEntr;
			nNext=aEntr.GetOffset();
			if (aEntr.Typ==aHead.Typ) {
				bRet=SgfFilterSDrw( rInp,aHead,aEntr,rMtf );
			}
		} // while(nNext)
		if (bRdFlag) {
			if (!rInp.GetError()) bRet=sal_True;  // Scheinbar Ok
		}
	}
	delete pSgfFonts;
	return(bRet);
}

/*
Bitmap Dither(sal_uInt8 Intens)
{
	Bitmap aBmp;
	BmpInfoHeader Info;


const dmatrix: array[0..7,0..7] of byte =
		((  0, 48, 12, 60,  3, 51, 15, 63 ),
		 ( 32, 16, 44, 28, 35, 19, 47, 31 ),
		 (  8, 56,  4, 52, 11, 59,  7, 55 ),
		 ( 40, 24, 36, 20, 43, 27, 39, 23 ),
		 (  2, 50, 14, 62,  1, 49, 13, 61 ),
		 ( 34, 18, 46, 30, 33, 17, 45, 29 ),
		 ( 10, 58,  6, 54,  9, 57,  5, 53 ),
		 ( 42, 26, 38, 22, 41, 25, 37, 21 ));


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


procedure SetColorIntens(col0,col1,bal: integer);
var cmatrix0: array[0..63] of byte absolute cmatrix;
	dmatrix0: array[0..63] of byte absolute dmatrix;
	n,i: integer;
	b,bit: byte;
begin
if col0=col1 then bal:=0;
if bal<=32 then
  begin
  plotcolor0:=col0 and $1F; plotcolor1:=col1 and $1F;
  plotbal:=bal;
  end
else
  begin
  plotcolor0:=col1 and $1F; plotcolor1:=col0 and $1F;
  plotbal:=64-bal;
  end;
for n:=0 to 63 do
 if plotbal<=dmatrix0[n] then cmatrix0[n]:=col0 else cmatrix0[n]:=col1;
end;
*/