#ifndef __INC_POSA_CLIB_GRAPHICS_PROTOS_C
#define __INC_POSA_CLIB_GRAPHICS_PROTOS_C
/*******************************************************************
 Includes Release 24
 (C) Copyright 1995-1997 proDAD
     All Rights Reserved

 $AUT Holger Burkarth
 $DAT >>graphics_protos.c<<   31 Jan 1997    19:44:49 - (C) ProDAD
*******************************************************************/
#define NOMYDEBUG
#pragma -

#include <exec/types.h>
#include <graphics/gfx.h>
#include <graphics/rastport.h>
#include <graphics/displayinfo.h>
#include <graphics/text.h>
#include "p:pProto/pGfx2.h"
#include "p:pProto/pLayer2.h"
#include "p:pProto/pIntui2.h"
#include "p:pProto/pExec2.h"
#include "p:pLayer/Region.h"
#include "p:pLayer/Clip.h"
#include "p:pExec/Library.h"
#include "p:pDOS/Segment.h"
#include "p:pGFX/Color.h"
#include "p:pGFX/MonFile.h"
#include "p:pGFX/RastPort.h"
#include "p:pGFX/View.h"
#include "p:pGFX/GfxTags.h"
#include "p:pGFX/StdGMap.h"
#include "p:pGFX/Text.h"
#include "p:pScreen/DrawInfo.h"
#include "p:pScreen/Screen.h"

#include <string.h>

/* mcpp:cppc -c ci:_Projekte/pOSxA/clib/graphics_protos.c -pc */


#pragma -

struct ColorMap* GetColorMapViewPort(struct ViewPort* vp)
{
  return( (struct ColorMap*) ((struct pOS_ViewPort*)vp)->vp_MonFile->mfh_ColorMap );
}

BOOL IsRTGLibrary(struct pOS_GfxLibrary* lib)
{
  BOOL Flg=FALSE;
  struct pOS_Library* Lib;
  if(lib) {
    Lib=(struct pOS_Library*)lib;
    if(Lib->lib_Node.ln_Type==NTYP_LIBRARY) {
      if(Lib->lib_Segm && Lib->lib_Segm->sel_Node.ln_Type==NTYP_SEGMENT) {
        return(TRUE);
      }
    }
  }
  return(Flg);
}

BOOL IsRTGGfxMap(struct pOS_GfxMap* map)
{
  BOOL Flg=FALSE;
  if(map && map->gm_Base!=NULL && map->gm_UserData[0]==0
     && map->gm_UserData[1]==0 && map->gm_Width>0 && map->gm_Width<17000
     && map->gm_Height>0 && map->gm_Height<17000)
  {
    Flg=IsRTGLibrary(map->gm_Base);
  }
  return(Flg);
}



LONG BltBitMap( struct BitMap *src, long xSrc, long ySrc,
        struct BitMap *destBitMap, long xDest, long yDest, long xSize,
        long ySize, unsigned long minterm, unsigned long mask,
        UBYTE* tempA )
  {
    pOS_StdPlanarGfxMap GM;
    UWORD d;

    memset(&GM,0,sizeof(GM)); /* *** Zur Sicherheit */
    GM.plgm_Gfx.gm_Type = GFXMAPTYP_StdPlanar;

    GM.plgm_Gfx.gm_Width =src->BytesPerRow*8;
    GM.plgm_Gfx.gm_Height=src->Rows;
    GM.plgm_BytesPerRow=src->BytesPerRow;
    GM.plgm_Depth=src->Depth;

    for(d=0; d<src->Depth; ++d) GM.plgm_Planes[d]=src->Planes[d];

    pOS_WriteStdGfxMap(&GM.plgm_Gfx,xSrc,ySrc,
       (struct pOS_GfxMap*)destBitMap,xDest,yDest,xSize,ySize, 0,NULL);
    return(1);
  }

void BltTemplate(UBYTE* source,long xSrc,long srcMod,struct RastPort *destRP,long xDest,long yDest,long xSize,long ySize)
  {  pOS_BltTemplate((UBYTE*)source,xSrc,srcMod,(struct pOS_RastPort*)destRP,xDest,yDest,xSize,ySize); }

WORD TextLength( struct RastPort *rp, STRPTR string, unsigned long count )
  { return(pOS_TextLength((struct pOS_RastPort*)rp,(CHAR*)string,count));}

void Text( struct RastPort *rp, STRPTR string, unsigned long count )
  { pOS_DrawText((struct pOS_RastPort*)rp,(CHAR*)string,count); }

void SetFont( struct RastPort *rp, struct TextFont *textFont )
  {  pOS_SetFont((struct pOS_RastPort*)rp,(struct pOS_TextFont*)textFont); }

struct TextFont *OpenFont( struct TextAttr *textAttr )
  { return((struct TextFont*)pOS_OpenFont((struct pOS_TextAttr*)textAttr));}

void CloseFont( struct TextFont *textFont )
  { pOS_CloseFont((struct pOS_TextFont*)textFont); }

ULONG AskSoftStyle( struct RastPort *rp)
  { return(pOS_AskSoftFontStyle((struct pOS_RastPort*)rp));}

ULONG SetSoftStyle( struct RastPort *rp, unsigned long style,unsigned long enable)
  { return(pOS_SetSoftFontStyle((struct pOS_RastPort*)rp,style,enable));}

void InitRastPort( struct RastPort *rp )
  {
    struct pOS_Screen *Scr=pOS_LockPubScreen(NULL);
    memset(rp,0,sizeof(struct RastPort));
    ((struct pOS_RastPort*)rp)->rp_Base=Scr->scr_DrawInfo->dri_Base;
    pOS_UnlockPubScreen(Scr);
  }

void SetRast( struct RastPort *rp, unsigned long pen )
  {
    ULONG MP=pOS_SetAPen((APTR)rp,pen);
    pOS_DrawRectFill((APTR)rp,0,0,8191,8191);
    pOS_SetAPen((APTR)rp,MP);
  }

void Move( struct RastPort *rp, long x, long y )
  { pOS_SetPosition((struct pOS_RastPort*)rp,x,y); }

void Draw( struct RastPort *rp, long x, long y )
  { pOS_DrawLine((struct pOS_RastPort*)rp,x,y); }

void RectFill(struct RastPort *rp,long xMin,long yMin,long xMax,long yMax )
  { pOS_DrawRectFill((struct pOS_RastPort*)rp,xMin,yMin,xMax,yMax); }

void BltPattern(struct RastPort *rp,UBYTE*  mask,long xMin,long yMin,long xMax,long yMax,ULONG maskBPR)
{}

ULONG ReadPixel( struct RastPort *rp, long x, long y )
  { return(pOS_GetPixel((struct pOS_RastPort*)rp,NULL,x,y));}

void WritePixel( struct RastPort *rp, long x, long y )
  { pOS_WritePixel((struct pOS_RastPort*)rp,x,y);}

void PolyDraw( struct RastPort *rp, long count, WORD *polyTable )
  { pOS_PolyDraw((struct pOS_RastPort*)rp,(struct pOS_WPoint*)polyTable,count);}

void SetAPen( struct RastPort *rp, unsigned long pen )
  { pOS_SetAPen((struct pOS_RastPort*)rp,pen); }

void SetBPen( struct RastPort *rp, unsigned long pen )
  { pOS_SetBPen((struct pOS_RastPort*)rp,pen); }

void SetDrMd( struct RastPort *rp, unsigned long drawMode )
  { pOS_SetDrMd((struct pOS_RastPort*)rp,drawMode);}

void InitBitMap(struct BitMap *bitMap,ULONG depth,ULONG width,ULONG height)
  {
    UWORD i;
    for(i=0; i<8; ++i) bitMap->Planes[i]=0;
    bitMap->Rows=height; bitMap->Depth=depth;
    bitMap->BytesPerRow=((width+15)>>4)<<1;
  }

void ScrollRaster(struct RastPort *rp,long dx,long dy,long xMin,long yMin,long xMax,long yMax)
  { pOS_ScrollRaster((struct pOS_RastPort*)rp,dx,dy,xMin,yMin,xMax,yMax,SCLRSTF_Std);}

void LockLayerRom( struct Layer *layer )
  { pOS_LockLayer((struct pOS_Layer*)layer); }

void UnlockLayerRom( struct Layer *layer )
  { pOS_UnlockLayer((struct pOS_Layer*)layer); }

void SyncSBitMap( struct Layer *layer )
  { pOS_CopySupToLayer((struct pOS_Layer*)layer); }

void CopySBitMap( struct Layer *layer )
  { pOS_CopyLayerToSup((struct pOS_Layer*)layer); }

void AddFont( struct TextFont *textFont )
  { pOS_AddFont((struct pOS_TextFont*)textFont); }

void RemFont( struct TextFont *textFont )
  { pOS_RemFont((struct pOS_TextFont*)textFont); }

void AndRectRegion( struct Region *region, struct Rectangle *rectangle )
  { pOS_AndRectRegion((struct pOS_Region*)region,(struct pOS_Rectangle*)rectangle); }

BOOL OrRectRegion( struct Region *region, struct Rectangle *rectangle )
  { return(pOS_OrRectRegion((struct pOS_Region*)region,(struct pOS_Rectangle*)rectangle));}

struct Region *NewRegion( void )
  { return((struct Region*)pOS_CreateRegion());}

BOOL ClearRectRegion( struct Region *region, struct Rectangle *rectangle )
  { return(pOS_NAndRectRegion((struct pOS_Region*)region,(struct pOS_Rectangle*)rectangle));}

void ClearRegion( struct Region *region )
  {
    struct pOS_Region* Reg=(struct pOS_Region*)region;
    pOS_ClearRegion(Reg,&Reg->rg_List);
  }

void DisposeRegion( struct Region *region )
  { pOS_DeleteRegion((struct pOS_Region*)region);}

void ClipBlit(struct RastPort *srcRP,long xSrc,long ySrc,struct RastPort *destRP,
        long xDest,long yDest,long xSize,long ySize,unsigned long minterm)
  {
    pOS_BltGfxMapClip((struct pOS_RastPort*)srcRP,xSrc,ySrc,(struct pOS_RastPort*)destRP,xDest,yDest,xSize,ySize,minterm);
  }

BOOL XorRectRegion( struct Region *region, struct Rectangle *rectangle )
  { return(pOS_XOrRectRegion((struct pOS_Region*)region,(struct pOS_Rectangle*)rectangle));}

struct ColorMap *GetColorMap( long entries )
  { return((APTR)pOS_AllocColorMap(NULL,
       GFXTAG_ColorType, COLMAPTYP_StdRLut,
       GFXTAG_Colors,    entries,
       TAG_END) );
  }

void FreeColorMap( struct ColorMap *colorMap )
  { pOS_FreeColorMap((APTR)colorMap); }

void BltBitMapRastPort(struct BitMap *src,long xSrc,long ySrc,struct RastPort *destRP,
        long xDest,long yDest,long xSize,long ySize,ULONG minterm)
  {
    pOS_StdPlanarGfxMap GM;
    UWORD d;

    memset(&GM,0,sizeof(GM)); /* *** Zur Sicherheit */
    GM.plgm_Gfx.gm_Type = GFXMAPTYP_StdPlanar;

    GM.plgm_Gfx.gm_Width =src->BytesPerRow*8;
    GM.plgm_Gfx.gm_Height=src->Rows;
    GM.plgm_BytesPerRow=src->BytesPerRow;
    GM.plgm_Depth=src->Depth;

    for(d=0; d<src->Depth; ++d) GM.plgm_Planes[d]=src->Planes[d];

    pOS_WriteStdGfxMapRastPort(&GM.plgm_Gfx,xSrc,ySrc,
       (struct pOS_RastPort*)destRP,xDest,yDest,xSize,ySize, 0);
  }


BOOL OrRegionRegion( struct Region *srcRegion, struct Region *destRegion )
  { return(pOS_OrRegionRegion((struct pOS_Region*)srcRegion,(struct pOS_Region*)destRegion));}


BOOL AndRegionRegion( struct Region *srcRegion, struct Region *destRegion )
  { return(pOS_AndRegionRegion((struct pOS_Region*)srcRegion,(struct pOS_Region*)destRegion));}


void SetRGB4CM(struct ColorMap *cm,ULONG index,ULONG r,ULONG g,ULONG b)
  {
    struct pOS_RColor RC;
    RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r*16;
    RC.rc_U.rc_E.rcue_G=g*16;    RC.rc_U.rc_E.rcue_B=b*16;
/*    pOS_SetColor((APTR)cm,index,&RC,1); */
  }

void BltMaskBitMapRastPort(struct BitMap *src, long xSrc, long ySrc,
        struct RastPort *destRP, long xDest, long yDest, long xSize,
        long ySize, unsigned long minterm,UBYTE* bltMask )
  {
    pOS_StdPlanarGfxMap GM;
    UWORD d;

    memset(&GM,0,sizeof(GM)); /* *** Zur Sicherheit */
    GM.plgm_Gfx.gm_Type = GFXMAPTYP_StdPlanar;

    GM.plgm_Gfx.gm_Width =src->BytesPerRow*8;
    GM.plgm_Gfx.gm_Height=src->Rows;
    GM.plgm_BytesPerRow=src->BytesPerRow;
    GM.plgm_Depth=src->Depth;

    for(d=0; d<src->Depth; ++d) GM.plgm_Planes[d]=src->Planes[d];

    pOS_WriteStdGfxMapRastPort(&GM.plgm_Gfx,xSrc,ySrc,
       (struct pOS_RastPort*)destRP,xDest,yDest,xSize,ySize, 0);
  }

BOOL AttemptLockLayerRom( struct Layer *layer )
  { return(pOS_AttemptSemaphore(&((struct pOS_Layer*)layer)->ly_Lock));}


void EraseRect(struct RastPort *rp,long xMin,long yMin,long xMax,long yMax)
  { pOS_EraseRect((APTR)rp,xMin,yMin,xMax,yMax); }

LONG ObtainBestPenA(struct ColorMap *cm,ULONG r,ULONG g,ULONG b,struct TagItem* tag)
  {
    struct pOS_RColor RC;
    RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r;
    RC.rc_U.rc_E.rcue_G=g;       RC.rc_U.rc_E.rcue_B=b;
    return(pOS_ObtainColorPen((APTR)cm,~0,&RC,OTCOLPF_Shared | OTCOLPF_Flow | OTCOLPF_Force | OTCOLPF_Display));
  }

LONG ObtainBestPen(struct ColorMap *cm,ULONG r,ULONG g,ULONG b,ULONG tag1Type, ...)
  { return( ObtainBestPenA(cm,r,g,b,(struct TagItem*)&tag1Type)); }

void SetRGB32(struct ViewPort *vp,ULONG n,ULONG r,ULONG g,ULONG b)
  {
    struct pOS_RColor RC;
    RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r;
    RC.rc_U.rc_E.rcue_G=g;       RC.rc_U.rc_E.rcue_B=b;
/*    pOS_SetColor((APTR)GetColorMapViewPort(vp),n,&RC,1); */
/*    pOS_DisplayColorMap((APTR)GetColorMapViewPort(vp),DISCOLF_Always); */
  }

void SetABPenDrMd(struct RastPort *rp,ULONG apen,ULONG bpen,ULONG drawmode )
  { pOS_SetABPenDrMd((struct pOS_RastPort*)rp,apen,bpen,drawmode); }

void FreeBitMap(struct BitMap *bm)
  {
/*kprintf("FreeBitMap<0x%lx> %ld\n",bm,IsRTGGfxMap( (struct pOS_GfxMap*)bm )); */

    if(IsRTGGfxMap( (struct pOS_GfxMap*)bm )) {
      pOS_FreeGfxMap( (struct pOS_GfxMap*)bm );
    }
    else {
      UWORD t;
      const size_t PlSize=bm->Rows*bm->BytesPerRow;
      for(t=0; t<bm->Depth; ++t) {
        if(bm->Planes[t]) pOS_FreeMem(bm->Planes[t],PlSize);
      }
      pOS_FreeMem(bm,sizeof(struct BitMap));
    }
  }

struct BitMap *AllocBitMap(ULONG sizex,ULONG sizey,ULONG depth,ULONG flags,
                           struct BitMap *friend_bitmap)
  {
/*kprintf("AllocBitMap %ld %ld  Fr=%lx %ld\n",sizex,sizey,friend_bitmap,IsRTGGfxMap( (struct pOS_GfxMap*)friend_bitmap )); */

    if(IsRTGGfxMap( (struct pOS_GfxMap*)friend_bitmap ) ) {
      return((struct BitMap*)pOS_AllocGfxMap( ((struct pOS_GfxMap*)friend_bitmap)->gm_Base,
             GFXTAG_Width,        sizex,
             GFXTAG_Height,       sizey,
             GFXTAG_Colors,       1<<depth,
             GFXTAG_FriendGfxMap, (ULONG)friend_bitmap,
             GFXTAG_GfxFlags,     flags,
             TAG_END));
    }
    else {
      struct BitMap* BM;
      size_t PlSize;
      UWORD t;
      ULONG Flg=MEMF_PUBLIC;

      if(flags & BMF_CLEAR)          Flg |= MEMF_CLEAR;
      if(!(flags & BMF_DISPLAYABLE)) Flg |= MEMF_VMEM;


      if(BM=(struct BitMap*)pOS_AllocMem(sizeof(struct BitMap),MEMF_CLEAR|MEMF_PUBLIC)) {
        InitBitMap(BM,depth,sizex,sizey);
        PlSize=BM->Rows*BM->BytesPerRow;

        for(t=0; t<BM->Depth; ++t) {
          BM->Planes[t]=(UBYTE*)pOS_AllocMem(PlSize,Flg);
          if(BM->Planes[t]==NULL) {
            FreeBitMap(BM);
            break;
          }
        }
      }
      return(BM);
    }
  }

void ReleasePen( struct ColorMap *cm, unsigned long n )
  { pOS_ReleaseColorPen((APTR)cm,n); }

ULONG ObtainPen(struct ColorMap *cm,ULONG n,ULONG r,ULONG g,ULONG b,ULONG flg )
  {
    struct pOS_RColor RC;
    RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r;
    RC.rc_U.rc_E.rcue_G=g;       RC.rc_U.rc_E.rcue_B=b;
    return(pOS_ObtainColorPen((APTR)cm,n,&RC,flg));
  }

ULONG GetBitMapAttr(struct BitMap *bm,ULONG attrnum)
  {
    ULONG ret;

    if(IsRTGGfxMap( (struct pOS_GfxMap*)bm ) ) {
      switch(attrnum) {
        case BMA_HEIGHT:
          ret=((struct pOS_GfxMap*)bm)->gm_Height;
          break;

        case BMA_WIDTH:
          ret=((struct pOS_GfxMap*)bm)->gm_Width;
          break;

        case BMA_DEPTH:
          ret=8;
          break;

        case BMA_FLAGS:
          ret=0;
          break;

        default: ret=0;
      }
    }
    else {

      switch(attrnum) {
        case BMA_HEIGHT:
          ret=bm->Rows;
          break;

        case BMA_WIDTH:
          ret=bm->BytesPerRow*8;
          break;

        case BMA_DEPTH:
          ret=bm->Depth;
          break;

        case BMA_FLAGS:
          ret=0;
          break;

        default: ret=0;
      }
    }
    return(ret);
  }

ULONG SetOutlinePen( struct RastPort *rp, unsigned long pen )
  { return( pOS_SetOPen((struct pOS_RastPort*)rp,pen) ); }



void SetRGB32CM(struct ColorMap *cm,ULONG n,ULONG r,ULONG g,ULONG b )
  {
    struct pOS_RColor RC;
    RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r;
    RC.rc_U.rc_E.rcue_G=g;       RC.rc_U.rc_E.rcue_B=b;
/*    pOS_SetColor((APTR)cm,n,&RC,1); */
  }


void ScrollRasterBF(struct RastPort *rp,SLONG dx,SLONG dy,SLONG xMin,SLONG yMin,SLONG xMax,SLONG yMax)
  {
    pOS_ScrollRaster((APTR)rp,dx,dy,xMin,yMin,xMax,yMax,SCLRSTF_Erase);
  }

void SetRPAttrsA( struct RastPort *rp, struct TagItem *tags )
  { pOS_SetRastPortA((APTR)rp,(APTR)tags);}

void SetRPAttrs( struct RastPort *rp, unsigned long tag1Type, ... )
  { pOS_SetRastPortA((APTR)rp,(APTR)&tag1Type);}

void GetRPAttrsA( struct RastPort *rp, struct TagItem *tags )
  { pOS_GetRastPortA((APTR)rp,(APTR)tags);}

void GetRPAttrs( struct RastPort *rp, unsigned long tag1Type, ... )
  { pOS_GetRastPortA((APTR)rp,(APTR)&tag1Type);}

/*MIC*/ ULONG GetDisplayInfoData(APTR handle, UBYTE *buf, ULONG size, ULONG type, ULONG id)
  {
    LONG Ret=0;  /* 0 im Fehlerfall als Returnwert */

    switch(type) {
      case DTAG_DISP:
        if(size >= sizeof(struct DisplayInfo))
        {
          struct DisplayInfo *Buf=(struct DisplayInfo *)buf;
          memset(Buf,0,sizeof(struct DisplayInfo));
          Buf->Resolution.x=640;
          Buf->Resolution.y=256;
          Ret=sizeof(struct DisplayInfo);
        }
        break;

      case DTAG_DIMS:
        if(size >= sizeof(struct DimensionInfo))
        {
          struct DimensionInfo *Buf=(struct DimensionInfo *)buf;
          memset(Buf,0,sizeof(struct DimensionInfo));
          Buf->MaxDepth=24;
          Buf->MinRasterWidth=640;
          Buf->MinRasterHeight=256;
          Buf->MaxRasterWidth=640;
          Buf->MaxRasterHeight=256;
          Buf->Nominal.MinX=0;
          Buf->Nominal.MaxX=0;
          Buf->Nominal.MinY=640;
          Buf->Nominal.MaxY=256;
          Buf->MaxOScan.MinX=0;
          Buf->MaxOScan.MinY=0;
          Buf->MaxOScan.MaxX=736;
          Buf->MaxOScan.MaxY=283;
          Buf->VideoOScan.MinX=0;
          Buf->VideoOScan.MinY=0;
          Buf->VideoOScan.MaxX=724;
          Buf->VideoOScan.MaxY=283;
          Buf->TxtOScan.MinX=0;
          Buf->TxtOScan.MinY=0;
          Buf->TxtOScan.MaxX=704;
          Buf->TxtOScan.MaxY=280;
          Buf->StdOScan.MinX=0;
          Buf->StdOScan.MinY=0;
          Buf->StdOScan.MaxX=704;
          Buf->StdOScan.MaxY=280;
          Ret=sizeof(struct DimensionInfo);
        }
        break;

      /*case DTAG_MNTR: */
      /*  break; */

      case DTAG_NAME:
        if(size >= sizeof(struct NameInfo))
        {
          struct NameInfo *Buf=(struct NameInfo *)buf;
          memset(Buf,0,sizeof(struct NameInfo));
          strcpy(Buf->Name,"PAL:HighRes");
          Ret=sizeof(struct NameInfo);
        }
        break;
    }
    return( Ret );
  }

/*MIC*/ LONG GetVPModeID( struct ViewPort *vp )
  { return( 0x8000 ); }

/*MIC*/ ULONG TextFit(struct RastPort *rp,STRPTR string, ULONG length, struct TextExtent *textextent, struct TextExtent *rectextent, LONG direction, ULONG rectwidth, ULONG recthight)
  {
    struct pOS_TextDim TextDim;
    TextDim.td_MaxWidth=rectextent ? rectextent->te_Width : rectwidth;
    pOS_CalcTextDim((pOS_RastPort*)rp,string,length,&TextDim,0);

    textextent->te_Width=pOS_TextLength((struct pOS_RastPort*)rp,string,length);
    textextent->te_Height=rp->Font->tf_YSize;
    textextent->te_Extend.MinX=0;
    textextent->te_Extend.MinY=0;
    textextent->te_Extend.MaxX=TextDim.td_UsedWidth;
    textextent->te_Extend.MaxY=textextent->te_Height;

    return( TextDim.td_UsedNumChars );
  }

/*MIC*/ WORD TextExtent(struct RastPort *rp, STRPTR string, LONG length, struct TextExtent *textextent)
  {
    struct pOS_TextDim TextDim;
    TextDim.td_MaxWidth=32000;
    pOS_CalcTextDim((pOS_RastPort*)rp,string,length,&TextDim,0);

    textextent->te_Width=pOS_TextLength((struct pOS_RastPort*)rp,string,length);
    textextent->te_Height=rp->Font->tf_YSize;
    textextent->te_Extend.MinX=0;
    textextent->te_Extend.MinY=0;
    textextent->te_Extend.MaxX=TextDim.td_UsedWidth;
    textextent->te_Extend.MaxY=textextent->te_Height;

    return( 0 );   /* Funktion wird als VOID beschrieben !! */
  }

ULONG GetAPen( struct RastPort *rp )
  {
    ULONG Res;
    pOS_GetRastPort((pOS_RastPort*)rp,
       GFXTAG_APen, (ULONG)&Res,
       TAG_END);
    return(Res);
  }

ULONG GetBPen( struct RastPort *rp )
  {
    ULONG Res;
    pOS_GetRastPort((pOS_RastPort*)rp,
       GFXTAG_BPen, (ULONG)&Res,
       TAG_END);
    return(Res);
  }

ULONG GetOutlinePen( struct RastPort *rp )
  {
    ULONG Res;
    pOS_GetRastPort((pOS_RastPort*)rp,
       GFXTAG_OPen, (ULONG)&Res,
       TAG_END);
    return(Res);
  }

void SetRGB4(struct ViewPort *vp,ULONG index,ULONG r,ULONG g,ULONG b)
  {
    struct pOS_RColor RC;
    RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r*16;
    RC.rc_U.rc_E.rcue_G=g*16;    RC.rc_U.rc_E.rcue_B=b*16;
    pOS_SetColor((APTR)GetColorMapViewPort(vp),index,&RC,1);
    pOS_DisplayColorMap((APTR)GetColorMapViewPort(vp),DISCOLF_Always);
  }

ULONG GetRGB4( struct ColorMap *colorMap, long entry )
  {
    struct pOS_RColor RC;
    pOS_GetColor((APTR)colorMap,entry,&RC,1);
    RC.rc_U.rc_E.rcue_R>>=4; RC.rc_U.rc_E.rcue_G>>=4; RC.rc_U.rc_E.rcue_B>>=4;
    return( (RC.rc_U.rc_E.rcue_R<<8) | (RC.rc_U.rc_E.rcue_G<<4) | RC.rc_U.rc_E.rcue_B);
  }

void LoadRGB4( struct ViewPort *vp, UWORD *colors, long count )
  {
    struct pOS_RColor RC;
    ULONG i;

    for(i=0; i<count; ++i,++colors) {
      RC.rc_U.rc_E.rcue_A=255;
      RC.rc_U.rc_E.rcue_R=((colors[0]>>8) & 0x0f) * 16;
      RC.rc_U.rc_E.rcue_G=((colors[0]>>4) & 0x0f) * 16;
      RC.rc_U.rc_E.rcue_B=((colors[0]>>0) & 0x0f) * 16;
      pOS_SetColor((APTR)GetColorMapViewPort(vp),i,&RC,1);
    }
    pOS_DisplayColorMap((APTR)GetColorMapViewPort(vp),DISCOLF_Always);
  }

LONG WritePixelArray8(struct RastPort* rp,ULONG x1,ULONG y1,ULONG x2,ULONG y2,
                      UBYTE* datas,struct RastPort* dummy)
  {
    ULONG Width=dummy->BitMap->BytesPerRow*8, Height=y2-y1+1;
    pOS_StdChunky8GfxMap GfxMap={NULL,0,0, Width,Height,GFXMAPTYP_StdChunky8};
    GfxMap.ckgm_Chunky=datas;

    pOS_WriteStdGfxMapRastPort(&GfxMap.ckgm_Gfx,0,0,
         (struct pOS_RastPort*)rp,x1,y1,x2-x1+1,Height, 0);
    return(0);
  }

LONG WritePixelLine8(struct RastPort* rp,ULONG x1,ULONG y1,ULONG width,
                     UBYTE* datas,struct RastPort* dummy)
  {
    ULONG Width=dummy->BitMap->BytesPerRow*8;
    pOS_StdChunky8GfxMap GfxMap={NULL,0,0, Width,1,GFXMAPTYP_StdChunky8};
    GfxMap.ckgm_Chunky=datas;

    pOS_WriteStdGfxMapRastPort(&GfxMap.ckgm_Gfx,0,0,
         (struct pOS_RastPort*)rp,x1,y1,width,1, 0);
    return(0);
  }

void WriteChunkyPixels(struct RastPort* rp,ULONG x1,ULONG y1,
                       ULONG x2,ULONG y2,UBYTE* datas,long bpr)
  {
    ULONG Width=bpr*8, Height=y2-y1+1;
    pOS_StdChunky8GfxMap GfxMap={NULL,0,0, Width,Height,GFXMAPTYP_StdChunky8};
    GfxMap.ckgm_Chunky=datas;

    pOS_WriteStdGfxMapRastPort(&GfxMap.ckgm_Gfx,0,0,
         (struct pOS_RastPort*)rp,x1,y1,x2-x1+1,Height, 0);
  }



#ifdef __IGNORE_NOT_SUPPORTED__


ULONG GetDrMd( struct RastPort *rp )
{return(0);}


void LoadRGB32( struct ViewPort *vp, ULONG *table )
{}

void ClearEOL( struct RastPort *rp )
{}
void ClearScreen( struct RastPort *rp )
{}
void AddBob( struct Bob *bob, struct RastPort *rp )
{}
void AddVSprite( struct VSprite *vSprite, struct RastPort *rp )
{}
void DoCollision( struct RastPort *rp )
{}
void DrawGList( struct RastPort *rp, struct ViewPort *vp )
{}
void InitGels(struct VSprite*,struct VSprite*,struct GelsInfo*)
{}
void InitMasks( struct VSprite *vSprite )
{}
void RemIBob( struct Bob *bob, struct RastPort *rp, struct ViewPort *vp )
{}
void RemVSprite( struct VSprite *vSprite )
{}
void SetCollision(ULONG num,APTR,struct GelsInfo*)
{}
void SortGList( struct RastPort *rp )
{}
void AddAnimOb(struct AnimOb*,struct AnimOb**,struct RastPort*)
{}
void Animate( struct AnimOb **anKey, struct RastPort *rp )
{}
BOOL GetGBuffers( struct AnimOb *anOb, struct RastPort *rp, long flag )
{return(0);}
void InitGMasks( struct AnimOb *anOb )
{}
void DrawEllipse(struct RastPort *rp,long xCenter,long yCenter,long a,long b)
{}
LONG AreaEllipse(struct RastPort *rp,long xCenter,long yCenter,long a,long b)
{return(0);}
void InitVPort( struct ViewPort *vp )
{}
ULONG MrgCop( struct View *view )
{return(0);}
ULONG MakeVPort( struct View *view, struct ViewPort *vp )
{return(0);}
void LoadView( struct View *view )
{}
void WaitBlit( void )
{}
LONG AreaMove( struct RastPort *rp, long x, long y )
{return(0);}
LONG AreaDraw( struct RastPort *rp, long x, long y )
{return(0);}
LONG AreaEnd( struct RastPort *rp )
{return(0);}
void WaitTOF( void )
{}
void QBlit( struct bltnode *blit )
{}
void InitArea( struct AreaInfo *areaInfo, APTR vectorBuffer,long maxVectors )
{}
void QBSBlit( struct bltnode *blit )
{}
void BltClear( PLANEPTR memBlock, unsigned long byteCount,ULONG flags )
{}
BOOL Flood( struct RastPort *rp, unsigned long mode, long x, long y )
{return(0);}
void InitView( struct View *view )
{}
void CBump( struct UCopList *copList )
{}
void CMove( struct UCopList *copList, APTR destination, long data )
{}
void CWait( struct UCopList *copList, long v, long h )
{}
LONG VBeamPos( void )
{return(0);}
void WaitBOVP( struct ViewPort *vp )
{}
WORD GetSprite( struct SimpleSprite *sprite, long num )
{return(0);}
void FreeSprite( long num )
{}
void ChangeSprite( struct ViewPort*,struct SimpleSprite*,PLANEPTR)
{}
void MoveSprite(struct ViewPort*,struct SimpleSprite*,long x,long y)
{}
void OwnBlitter( void )
{}
void DisownBlitter( void )
{}
struct TmpRas *InitTmpRas(struct TmpRas*,PLANEPTR buffer,long size)
{return(0);}
void AskFont( struct RastPort *rp, struct TextAttr *textAttr )
{}
PLANEPTR AllocRaster( unsigned long width, unsigned long height )
{return(0);}
void FreeRaster( PLANEPTR p, unsigned long width, unsigned long height )
{}
void FreeVPortCopLists( struct ViewPort *vp )
{}
void FreeCopList( struct CopList *copList )
{}
void FreeCprList( struct cprlist *cprList )
{}
void ScrollVPort( struct ViewPort *vp )
{}
struct CopList *UCopperListInit( struct UCopList *uCopList, long n )
{return(0);}
void FreeGBuffers( struct AnimOb *anOb, struct RastPort *rp, long flag )
{}
APTR GfxNew( unsigned long gfxNodeType )
{return(0);}
void GfxFree( APTR gfxNodePtr )
{}
void GfxAssociate( APTR associateNode, APTR gfxNodePtr )
{}
void BitMapScale( struct BitScaleArgs *bitScaleArgs )
{}
UWORD ScalerDiv(ULONG factor,ULONG numerator,ULONG denominator )
{return(0);}
APTR GfxLookUp( APTR associateNode )
{return(0);}
BOOL VideoControl( struct ColorMap *colorMap, struct TagItem *tagarray )
{return(0);}
BOOL VideoControlTags( struct ColorMap *colorMap,ULONG tag1Type,... )
{return(0);}
struct MonitorSpec *OpenMonitor( STRPTR monitorName,ULONG displayID )
{return(0);}
BOOL CloseMonitor( struct MonitorSpec *monitorSpec )
{return(0);}
APTR FindDisplayInfo( unsigned long displayID )
{return(0);}
ULONG NextDisplayInfo( unsigned long displayID )
{return(0);}
void FontExtent( struct TextFont *font, struct TextExtent *fontExtent )
{}
LONG ReadPixelLine8(struct RastPort*,ULONG,ULONG,ULONG,UBYTE*,struct RastPort*)
{return(0);}
LONG ReadPixelArray8(struct RastPort*,ULONG,ULONG,ULONG,ULONG,UBYTE*,struct RastPort*)
{return(0);}
LONG ModeNotAvailable( unsigned long modeID )
{return(0);}
WORD WeighTAMatch(struct TextAttr*,struct TextAttr*,struct TagItem*)
{return(0);}
WORD WeighTAMatchTags(struct TextAttr*,struct TextAttr*,ULONG, ... )
{return(0);}
ULONG ExtendFont( struct TextFont *font, struct TagItem *fontTags )
{return(0);}
ULONG ExtendFontTags( struct TextFont *font, unsigned long tag1Type, ... )
{return(0);}
void StripFont( struct TextFont *font )
{}
UWORD CalcIVG( struct View *v, struct ViewPort *vp )
{return(0);}
LONG AttachPalExtra( struct ColorMap *cm, struct ViewPort *vp )
{return(0);}
ULONG SetChipRev( unsigned long want )
{return(0);}
LONG GetExtSpriteA( struct ExtSprite *ss, struct TagItem *tags )
{return(0);}
LONG GetExtSprite( struct ExtSprite *ss, unsigned long tag1Type, ... )
{return(0);}
ULONG CoerceMode( struct ViewPort *vp,ULONG monitorid,ULONG flags )
{return(0);}
void ChangeVPBitMap(struct ViewPort *vp,struct BitMap *bm,struct DBufInfo *db)
{}
struct DBufInfo *AllocDBufInfo( struct ViewPort *vp )
{return(0);}
void FreeDBufInfo( struct DBufInfo *dbi )
{}
ULONG SetWriteMask( struct RastPort *rp, unsigned long msk )
{return(0);}
void SetMaxPen( struct RastPort *rp, unsigned long maxpen )
{}
LONG FindColor( struct ColorMap *cm,ULONG r,ULONG g,ULONG b,long maxcolor )
{return(0);}
struct ExtSprite *AllocSpriteDataA( struct BitMap *bm, struct TagItem *tags )
{return(0);}
struct ExtSprite *AllocSpriteData( struct BitMap *bm,ULONG tag1Type,... )
{return(0);}
LONG ChangeExtSpriteA(struct ViewPort*,struct ExtSprite*,struct ExtSprite*,struct TagItem*)
{return(0);}
LONG ChangeExtSprite(struct ViewPort*,struct ExtSprite*,struct ExtSprite*,ULONG tag1Type, ... )
{return(0);}
void FreeSpriteData( struct ExtSprite *sp )
{}
ULONG BestModeIDA( struct TagItem *tags )
{return(0);}
ULONG BestModeID( unsigned long tag1Type, ... )
{return(0);}

BOOL XorRegionRegion( struct Region *srcRegion, struct Region *destRegion )
{return(0);}
/*  { return(pOS_XorRegionRegion((pOS_Region*)srcRegion,(pOS_Region*)destRegion));} */

#endif  /** __IGNORE_NOT_SUPPORTED__ **/



#endif