home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / DC-POS24.LZX / pOS / pOSxA.lzx / pOSxA / clib / graphics_protos.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-03-12  |  26.9 KB  |  879 lines
  1. #ifndef __INC_POSA_CLIB_GRAPHICS_PROTOS_C
  2. #define __INC_POSA_CLIB_GRAPHICS_PROTOS_C
  3. /*******************************************************************
  4.  $CRT 09 Jul 1996 : hb
  5.  
  6.  $AUT Holger Burkarth
  7.  $DAT >>graphics_protos.c<<   31 Jan 1997    19:44:49 - (C) ProDAD
  8. *******************************************************************/
  9. #define NOMYDEBUG
  10. #pragma -
  11.  
  12. #include <exec/types.h>
  13. #include <graphics/gfx.h>
  14. #include <graphics/rastport.h>
  15. #include <graphics/displayinfo.h>
  16. #include <graphics/text.h>
  17. #include "p:proto/pGfx2.h"
  18. #include "p:proto/pLayer2.h"
  19. #include "p:proto/pIntui2.h"
  20. #include "p:proto/pExec2.h"
  21. #include "p:pLayer/Region.h"
  22. #include "p:pLayer/Clip.h"
  23. #include "p:pExec/Library.h"
  24. #include "p:pDOS/Segment.h"
  25. #include "p:pGFX/Color.h"
  26. #include "p:pGFX/MonFile.h"
  27. #include "p:pGFX/RastPort.h"
  28. #include "p:pGFX/View.h"
  29. #include "p:pGFX/GfxTags.h"
  30. #include "p:pGFX/StdGMap.h"
  31. #include "p:pGFX/Text.h"
  32. #include "p:pScreen/DrawInfo.h"
  33. #include "p:pScreen/Screen.h"
  34.  
  35. #include <string.h>
  36.  
  37. // mcpp:cppc -c ci:_Projekte/pOSxA/clib/graphics_protos.c -pc
  38.  
  39.  
  40. #pragma -
  41.  
  42. struct ColorMap* GetColorMapViewPort(struct ViewPort* vp)
  43. {
  44.   return( (struct ColorMap*) ((struct pOS_ViewPort*)vp)->vp_MonFile->mfh_ColorMap );
  45. }
  46.  
  47. BOOL IsRTGLibrary(struct pOS_GfxLibrary* lib)
  48. {
  49.   BOOL Flg=FALSE;
  50.   struct pOS_Library* Lib;
  51.   if(lib) {
  52.     Lib=(struct pOS_Library*)lib;
  53.     if(Lib->lib_Node.ln_Type==NTYP_LIBRARY) {
  54.       if(Lib->lib_Segm && Lib->lib_Segm->sel_Node.ln_Type==NTYP_SEGMENT) {
  55.         return(TRUE);
  56.       }
  57.     }
  58.   }
  59.   return(Flg);
  60. }
  61.  
  62. BOOL IsRTGGfxMap(struct pOS_GfxMap* map)
  63. {
  64.   BOOL Flg=FALSE;
  65.   if(map && map->gm_Base!=NULL && map->gm_UserData[0]==0
  66.      && map->gm_UserData[1]==0 && map->gm_Width>0 && map->gm_Width<17000
  67.      && map->gm_Height>0 && map->gm_Height<17000)
  68.   {
  69.     Flg=IsRTGLibrary(map->gm_Base);
  70.   }
  71.   return(Flg);
  72. }
  73.  
  74.  
  75.  
  76. LONG BltBitMap( struct BitMap *src, long xSrc, long ySrc,
  77.         struct BitMap *destBitMap, long xDest, long yDest, long xSize,
  78.         long ySize, unsigned long minterm, unsigned long mask,
  79.         UBYTE* tempA )
  80.   {
  81.     pOS_StdPlanarGfxMap GM;
  82.     UWORD d;
  83.  
  84.     memset(&GM,0,sizeof(GM)); // *** Zur Sicherheit
  85.     GM.plgm_Gfx.gm_Type = GFXMAPTYP_StdPlanar;
  86.  
  87.     GM.plgm_Gfx.gm_Width =src->BytesPerRow*8;
  88.     GM.plgm_Gfx.gm_Height=src->Rows;
  89.     GM.plgm_BytesPerRow=src->BytesPerRow;
  90.     GM.plgm_Depth=src->Depth;
  91.  
  92.     for(d=0; d<src->Depth; ++d) GM.plgm_Planes[d]=src->Planes[d];
  93.  
  94.     pOS_WriteStdGfxMap(&GM.plgm_Gfx,xSrc,ySrc,
  95.        (struct pOS_GfxMap*)destBitMap,xDest,yDest,xSize,ySize, 0,NULL);
  96.     return(1);
  97.   }
  98.  
  99. void BltTemplate(UBYTE* source,long xSrc,long srcMod,struct RastPort *destRP,long xDest,long yDest,long xSize,long ySize)
  100.   {  pOS_BltTemplate((UBYTE*)source,xSrc,srcMod,(struct pOS_RastPort*)destRP,xDest,yDest,xSize,ySize); }
  101.  
  102. WORD TextLength( struct RastPort *rp, STRPTR string, unsigned long count )
  103.   { return(pOS_TextLength((struct pOS_RastPort*)rp,(CHAR*)string,count));}
  104.  
  105. void Text( struct RastPort *rp, STRPTR string, unsigned long count )
  106.   { pOS_DrawText((struct pOS_RastPort*)rp,(CHAR*)string,count); }
  107.  
  108. void SetFont( struct RastPort *rp, struct TextFont *textFont )
  109.   {  pOS_SetFont((struct pOS_RastPort*)rp,(struct pOS_TextFont*)textFont); }
  110.  
  111. struct TextFont *OpenFont( struct TextAttr *textAttr )
  112.   { return((struct TextFont*)pOS_OpenFont((struct pOS_TextAttr*)textAttr));}
  113.  
  114. void CloseFont( struct TextFont *textFont )
  115.   { pOS_CloseFont((struct pOS_TextFont*)textFont); }
  116.  
  117. ULONG AskSoftStyle( struct RastPort *rp)
  118.   { return(pOS_AskSoftFontStyle((struct pOS_RastPort*)rp));}
  119.  
  120. ULONG SetSoftStyle( struct RastPort *rp, unsigned long style,unsigned long enable)
  121.   { return(pOS_SetSoftFontStyle((struct pOS_RastPort*)rp,style,enable));}
  122.  
  123. void InitRastPort( struct RastPort *rp )
  124.   {
  125.     struct pOS_Screen *Scr=pOS_LockPubScreen(NULL);
  126.     memset(rp,0,sizeof(struct RastPort));
  127.     ((struct pOS_RastPort*)rp)->rp_Base=Scr->scr_DrawInfo->dri_Base;
  128.     pOS_UnlockPubScreen(Scr);
  129.   }
  130.  
  131. void SetRast( struct RastPort *rp, unsigned long pen )
  132.   {
  133.     ULONG MP=pOS_SetAPen((APTR)rp,pen);
  134.     pOS_DrawRectFill((APTR)rp,0,0,8191,8191);
  135.     pOS_SetAPen((APTR)rp,MP);
  136.   }
  137.  
  138. void Move( struct RastPort *rp, long x, long y )
  139.   { pOS_SetPosition((struct pOS_RastPort*)rp,x,y); }
  140.  
  141. void Draw( struct RastPort *rp, long x, long y )
  142.   { pOS_DrawLine((struct pOS_RastPort*)rp,x,y); }
  143.  
  144. void RectFill(struct RastPort *rp,long xMin,long yMin,long xMax,long yMax )
  145.   { pOS_DrawRectFill((struct pOS_RastPort*)rp,xMin,yMin,xMax,yMax); }
  146.  
  147. void BltPattern(struct RastPort *rp,UBYTE*  mask,long xMin,long yMin,long xMax,long yMax,ULONG maskBPR)
  148. {}
  149.  
  150. ULONG ReadPixel( struct RastPort *rp, long x, long y )
  151.   { return(pOS_GetPixel((struct pOS_RastPort*)rp,NULL,x,y));}
  152.  
  153. void WritePixel( struct RastPort *rp, long x, long y )
  154.   { pOS_WritePixel((struct pOS_RastPort*)rp,x,y);}
  155.  
  156. void PolyDraw( struct RastPort *rp, long count, WORD *polyTable )
  157.   { pOS_PolyDraw((struct pOS_RastPort*)rp,(struct pOS_WPoint*)polyTable,count);}
  158.  
  159. void SetAPen( struct RastPort *rp, unsigned long pen )
  160.   { pOS_SetAPen((struct pOS_RastPort*)rp,pen); }
  161.  
  162. void SetBPen( struct RastPort *rp, unsigned long pen )
  163.   { pOS_SetBPen((struct pOS_RastPort*)rp,pen); }
  164.  
  165. void SetDrMd( struct RastPort *rp, unsigned long drawMode )
  166.   { pOS_SetDrMd((struct pOS_RastPort*)rp,drawMode);}
  167.  
  168. void InitBitMap(struct BitMap *bitMap,ULONG depth,ULONG width,ULONG height)
  169.   {
  170.     UWORD i;
  171.     for(i=0; i<8; ++i) bitMap->Planes[i]=0;
  172.     bitMap->Rows=height; bitMap->Depth=depth;
  173.     bitMap->BytesPerRow=((width+15)>>4)<<1;
  174.   }
  175.  
  176. void ScrollRaster(struct RastPort *rp,long dx,long dy,long xMin,long yMin,long xMax,long yMax)
  177.   { pOS_ScrollRaster((struct pOS_RastPort*)rp,dx,dy,xMin,yMin,xMax,yMax,SCLRSTF_Std);}
  178.  
  179. void LockLayerRom( struct Layer *layer )
  180.   { pOS_LockLayer((struct pOS_Layer*)layer); }
  181.  
  182. void UnlockLayerRom( struct Layer *layer )
  183.   { pOS_UnlockLayer((struct pOS_Layer*)layer); }
  184.  
  185. void SyncSBitMap( struct Layer *layer )
  186.   { pOS_CopySupToLayer((struct pOS_Layer*)layer); }
  187.  
  188. void CopySBitMap( struct Layer *layer )
  189.   { pOS_CopyLayerToSup((struct pOS_Layer*)layer); }
  190.  
  191. void AddFont( struct TextFont *textFont )
  192.   { pOS_AddFont((struct pOS_TextFont*)textFont); }
  193.  
  194. void RemFont( struct TextFont *textFont )
  195.   { pOS_RemFont((struct pOS_TextFont*)textFont); }
  196.  
  197. void AndRectRegion( struct Region *region, struct Rectangle *rectangle )
  198.   { pOS_AndRectRegion((struct pOS_Region*)region,(struct pOS_Rectangle*)rectangle); }
  199.  
  200. BOOL OrRectRegion( struct Region *region, struct Rectangle *rectangle )
  201.   { return(pOS_OrRectRegion((struct pOS_Region*)region,(struct pOS_Rectangle*)rectangle));}
  202.  
  203. struct Region *NewRegion( void )
  204.   { return((struct Region*)pOS_CreateRegion());}
  205.  
  206. BOOL ClearRectRegion( struct Region *region, struct Rectangle *rectangle )
  207.   { return(pOS_NAndRectRegion((struct pOS_Region*)region,(struct pOS_Rectangle*)rectangle));}
  208.  
  209. void ClearRegion( struct Region *region )
  210.   {
  211.     struct pOS_Region* Reg=(struct pOS_Region*)region;
  212.     pOS_ClearRegion(Reg,&Reg->rg_List);
  213.   }
  214.  
  215. void DisposeRegion( struct Region *region )
  216.   { pOS_DeleteRegion((struct pOS_Region*)region);}
  217.  
  218. void ClipBlit(struct RastPort *srcRP,long xSrc,long ySrc,struct RastPort *destRP,
  219.         long xDest,long yDest,long xSize,long ySize,unsigned long minterm)
  220.   {
  221.     pOS_BltGfxMapClip((struct pOS_RastPort*)srcRP,xSrc,ySrc,(struct pOS_RastPort*)destRP,xDest,yDest,xSize,ySize,minterm);
  222.   }
  223.  
  224. BOOL XorRectRegion( struct Region *region, struct Rectangle *rectangle )
  225.   { return(pOS_XOrRectRegion((struct pOS_Region*)region,(struct pOS_Rectangle*)rectangle));}
  226.  
  227. struct ColorMap *GetColorMap( long entries )
  228.   { return((APTR)pOS_AllocColorMap(NULL,
  229.        GFXTAG_ColorType, COLMAPTYP_StdRLut,
  230.        GFXTAG_Colors,    entries,
  231.        TAG_END) );
  232.   }
  233.  
  234. void FreeColorMap( struct ColorMap *colorMap )
  235.   { pOS_FreeColorMap((APTR)colorMap); }
  236.  
  237. void BltBitMapRastPort(struct BitMap *src,long xSrc,long ySrc,struct RastPort *destRP,
  238.         long xDest,long yDest,long xSize,long ySize,ULONG minterm)
  239.   {
  240.     pOS_StdPlanarGfxMap GM;
  241.     UWORD d;
  242.  
  243.     memset(&GM,0,sizeof(GM)); // *** Zur Sicherheit
  244.     GM.plgm_Gfx.gm_Type = GFXMAPTYP_StdPlanar;
  245.  
  246.     GM.plgm_Gfx.gm_Width =src->BytesPerRow*8;
  247.     GM.plgm_Gfx.gm_Height=src->Rows;
  248.     GM.plgm_BytesPerRow=src->BytesPerRow;
  249.     GM.plgm_Depth=src->Depth;
  250.  
  251.     for(d=0; d<src->Depth; ++d) GM.plgm_Planes[d]=src->Planes[d];
  252.  
  253.     pOS_WriteStdGfxMapRastPort(&GM.plgm_Gfx,xSrc,ySrc,
  254.        (struct pOS_RastPort*)destRP,xDest,yDest,xSize,ySize, 0);
  255.   }
  256.  
  257.  
  258. BOOL OrRegionRegion( struct Region *srcRegion, struct Region *destRegion )
  259.   { return(pOS_OrRegionRegion((struct pOS_Region*)srcRegion,(struct pOS_Region*)destRegion));}
  260.  
  261.  
  262. BOOL AndRegionRegion( struct Region *srcRegion, struct Region *destRegion )
  263.   { return(pOS_AndRegionRegion((struct pOS_Region*)srcRegion,(struct pOS_Region*)destRegion));}
  264.  
  265.  
  266. void SetRGB4CM(struct ColorMap *cm,ULONG index,ULONG r,ULONG g,ULONG b)
  267.   {
  268.     struct pOS_RColor RC;
  269.     RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r*16;
  270.     RC.rc_U.rc_E.rcue_G=g*16;    RC.rc_U.rc_E.rcue_B=b*16;
  271. //    pOS_SetColor((APTR)cm,index,&RC,1);
  272.   }
  273.  
  274. void BltMaskBitMapRastPort(struct BitMap *src, long xSrc, long ySrc,
  275.         struct RastPort *destRP, long xDest, long yDest, long xSize,
  276.         long ySize, unsigned long minterm,UBYTE* bltMask )
  277.   {
  278.     pOS_StdPlanarGfxMap GM;
  279.     UWORD d;
  280.  
  281.     memset(&GM,0,sizeof(GM)); // *** Zur Sicherheit
  282.     GM.plgm_Gfx.gm_Type = GFXMAPTYP_StdPlanar;
  283.  
  284.     GM.plgm_Gfx.gm_Width =src->BytesPerRow*8;
  285.     GM.plgm_Gfx.gm_Height=src->Rows;
  286.     GM.plgm_BytesPerRow=src->BytesPerRow;
  287.     GM.plgm_Depth=src->Depth;
  288.  
  289.     for(d=0; d<src->Depth; ++d) GM.plgm_Planes[d]=src->Planes[d];
  290.  
  291.     pOS_WriteStdGfxMapRastPort(&GM.plgm_Gfx,xSrc,ySrc,
  292.        (struct pOS_RastPort*)destRP,xDest,yDest,xSize,ySize, 0);
  293.   }
  294.  
  295. BOOL AttemptLockLayerRom( struct Layer *layer )
  296.   { return(pOS_AttemptSemaphore(&((struct pOS_Layer*)layer)->ly_Lock));}
  297.  
  298.  
  299. void EraseRect(struct RastPort *rp,long xMin,long yMin,long xMax,long yMax)
  300.   { pOS_EraseRect((APTR)rp,xMin,yMin,xMax,yMax); }
  301.  
  302. LONG ObtainBestPenA(struct ColorMap *cm,ULONG r,ULONG g,ULONG b,struct TagItem* tag)
  303.   {
  304.     struct pOS_RColor RC;
  305.     RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r;
  306.     RC.rc_U.rc_E.rcue_G=g;       RC.rc_U.rc_E.rcue_B=b;
  307.     return(pOS_ObtainColorPen((APTR)cm,~0,&RC,OTCOLPF_Shared | OTCOLPF_Flow | OTCOLPF_Force | OTCOLPF_Display));
  308.   }
  309.  
  310. LONG ObtainBestPen(struct ColorMap *cm,ULONG r,ULONG g,ULONG b,ULONG tag1Type, ...)
  311.   { return( ObtainBestPenA(cm,r,g,b,(struct TagItem*)&tag1Type)); }
  312.  
  313. void SetRGB32(struct ViewPort *vp,ULONG n,ULONG r,ULONG g,ULONG b)
  314.   {
  315.     struct pOS_RColor RC;
  316.     RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r;
  317.     RC.rc_U.rc_E.rcue_G=g;       RC.rc_U.rc_E.rcue_B=b;
  318. //    pOS_SetColor((APTR)GetColorMapViewPort(vp),n,&RC,1);
  319. //    pOS_DisplayColorMap((APTR)GetColorMapViewPort(vp),DISCOLF_Always);
  320.   }
  321.  
  322. void SetABPenDrMd(struct RastPort *rp,ULONG apen,ULONG bpen,ULONG drawmode )
  323.   { pOS_SetABPenDrMd((struct pOS_RastPort*)rp,apen,bpen,drawmode); }
  324.  
  325. void FreeBitMap(struct BitMap *bm)
  326.   {
  327. //kprintf("FreeBitMap<0x%lx> %ld\n",bm,IsRTGGfxMap( (struct pOS_GfxMap*)bm ));
  328.  
  329.     if(IsRTGGfxMap( (struct pOS_GfxMap*)bm )) {
  330.       pOS_FreeGfxMap( (struct pOS_GfxMap*)bm );
  331.     }
  332.     else {
  333.       UWORD t;
  334.       const size_t PlSize=bm->Rows*bm->BytesPerRow;
  335.       for(t=0; t<bm->Depth; ++t) {
  336.         if(bm->Planes[t]) pOS_FreeMem(bm->Planes[t],PlSize);
  337.       }
  338.       pOS_FreeMem(bm,sizeof(struct BitMap));
  339.     }
  340.   }
  341.  
  342. struct BitMap *AllocBitMap(ULONG sizex,ULONG sizey,ULONG depth,ULONG flags,
  343.                            struct BitMap *friend_bitmap)
  344.   {
  345. //kprintf("AllocBitMap %ld %ld  Fr=%lx %ld\n",sizex,sizey,friend_bitmap,IsRTGGfxMap( (struct pOS_GfxMap*)friend_bitmap ));
  346.  
  347.     if(IsRTGGfxMap( (struct pOS_GfxMap*)friend_bitmap ) ) {
  348.       return((struct BitMap*)pOS_AllocGfxMap( ((struct pOS_GfxMap*)friend_bitmap)->gm_Base,
  349.              GFXTAG_Width,        sizex,
  350.              GFXTAG_Height,       sizey,
  351.              GFXTAG_Colors,       1<<depth,
  352.              GFXTAG_FriendGfxMap, (ULONG)friend_bitmap,
  353.              GFXTAG_GfxFlags,     flags,
  354.              TAG_END));
  355.     }
  356.     else {
  357.       struct BitMap* BM;
  358.       size_t PlSize;
  359.       UWORD t;
  360.       ULONG Flg=MEMF_PUBLIC;
  361.  
  362.       if(flags & BMF_CLEAR)          Flg |= MEMF_CLEAR;
  363.       if(!(flags & BMF_DISPLAYABLE)) Flg |= MEMF_VMEM;
  364.  
  365.  
  366.       if(BM=(struct BitMap*)pOS_AllocMem(sizeof(struct BitMap),MEMF_CLEAR|MEMF_PUBLIC)) {
  367.         InitBitMap(BM,depth,sizex,sizey);
  368.         PlSize=BM->Rows*BM->BytesPerRow;
  369.  
  370.         for(t=0; t<BM->Depth; ++t) {
  371.           BM->Planes[t]=(UBYTE*)pOS_AllocMem(PlSize,Flg);
  372.           if(BM->Planes[t]==NULL) {
  373.             FreeBitMap(BM);
  374.             break;
  375.           }
  376.         }
  377.       }
  378.       return(BM);
  379.     }
  380.   }
  381.  
  382. void ReleasePen( struct ColorMap *cm, unsigned long n )
  383.   { pOS_ReleaseColorPen((APTR)cm,n); }
  384.  
  385. ULONG ObtainPen(struct ColorMap *cm,ULONG n,ULONG r,ULONG g,ULONG b,ULONG flg )
  386.   {
  387.     struct pOS_RColor RC;
  388.     RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r;
  389.     RC.rc_U.rc_E.rcue_G=g;       RC.rc_U.rc_E.rcue_B=b;
  390.     return(pOS_ObtainColorPen((APTR)cm,n,&RC,flg));
  391.   }
  392.  
  393. ULONG GetBitMapAttr(struct BitMap *bm,ULONG attrnum)
  394.   {
  395.     ULONG ret;
  396.  
  397.     if(IsRTGGfxMap( (struct pOS_GfxMap*)bm ) ) {
  398.       switch(attrnum) {
  399.         case BMA_HEIGHT:
  400.           ret=((struct pOS_GfxMap*)bm)->gm_Height;
  401.           break;
  402.  
  403.         case BMA_WIDTH:
  404.           ret=((struct pOS_GfxMap*)bm)->gm_Width;
  405.           break;
  406.  
  407.         case BMA_DEPTH:
  408.           ret=8;
  409.           break;
  410.  
  411.         case BMA_FLAGS:
  412.           ret=0;
  413.           break;
  414.  
  415.         default: ret=0;
  416.       }
  417.     }
  418.     else {
  419.  
  420.       switch(attrnum) {
  421.         case BMA_HEIGHT:
  422.           ret=bm->Rows;
  423.           break;
  424.  
  425.         case BMA_WIDTH:
  426.           ret=bm->BytesPerRow*8;
  427.           break;
  428.  
  429.         case BMA_DEPTH:
  430.           ret=bm->Depth;
  431.           break;
  432.  
  433.         case BMA_FLAGS:
  434.           ret=0;
  435.           break;
  436.  
  437.         default: ret=0;
  438.       }
  439.     }
  440.     return(ret);
  441.   }
  442.  
  443. ULONG SetOutlinePen( struct RastPort *rp, unsigned long pen )
  444.   { return( pOS_SetOPen((struct pOS_RastPort*)rp,pen) ); }
  445.  
  446.  
  447.  
  448. void SetRGB32CM(struct ColorMap *cm,ULONG n,ULONG r,ULONG g,ULONG b )
  449.   {
  450.     struct pOS_RColor RC;
  451.     RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r;
  452.     RC.rc_U.rc_E.rcue_G=g;       RC.rc_U.rc_E.rcue_B=b;
  453. //    pOS_SetColor((APTR)cm,n,&RC,1);
  454.   }
  455.  
  456.  
  457. void ScrollRasterBF(struct RastPort *rp,SLONG dx,SLONG dy,SLONG xMin,SLONG yMin,SLONG xMax,SLONG yMax)
  458.   {
  459.     pOS_ScrollRaster((APTR)rp,dx,dy,xMin,yMin,xMax,yMax,SCLRSTF_Erase);
  460.   }
  461.  
  462. void SetRPAttrsA( struct RastPort *rp, struct TagItem *tags )
  463.   { pOS_SetRastPortA((APTR)rp,(APTR)tags);}
  464.  
  465. void SetRPAttrs( struct RastPort *rp, unsigned long tag1Type, ... )
  466.   { pOS_SetRastPortA((APTR)rp,(APTR)&tag1Type);}
  467.  
  468. void GetRPAttrsA( struct RastPort *rp, struct TagItem *tags )
  469.   { pOS_GetRastPortA((APTR)rp,(APTR)tags);}
  470.  
  471. void GetRPAttrs( struct RastPort *rp, unsigned long tag1Type, ... )
  472.   { pOS_GetRastPortA((APTR)rp,(APTR)&tag1Type);}
  473.  
  474. /*MIC*/ ULONG GetDisplayInfoData(APTR handle, UBYTE *buf, ULONG size, ULONG type, ULONG id)
  475.   {
  476.     LONG Ret=0;  /* 0 im Fehlerfall als Returnwert */
  477.  
  478.     switch(type) {
  479.       case DTAG_DISP:
  480.         if(size >= sizeof(struct DisplayInfo))
  481.         {
  482.           struct DisplayInfo *Buf=(struct DisplayInfo *)buf;
  483.           memset(Buf,0,sizeof(struct DisplayInfo));
  484.           Buf->Resolution.x=640;
  485.           Buf->Resolution.y=256;
  486.           Ret=sizeof(struct DisplayInfo);
  487.         }
  488.         break;
  489.  
  490.       case DTAG_DIMS:
  491.         if(size >= sizeof(struct DimensionInfo))
  492.         {
  493.           struct DimensionInfo *Buf=(struct DimensionInfo *)buf;
  494.           memset(Buf,0,sizeof(struct DimensionInfo));
  495.           Buf->MaxDepth=24;
  496.           Buf->MinRasterWidth=640;
  497.           Buf->MinRasterHeight=256;
  498.           Buf->MaxRasterWidth=640;
  499.           Buf->MaxRasterHeight=256;
  500.           Buf->Nominal.MinX=0;
  501.           Buf->Nominal.MaxX=0;
  502.           Buf->Nominal.MinY=640;
  503.           Buf->Nominal.MaxY=256;
  504.           Buf->MaxOScan.MinX=0;
  505.           Buf->MaxOScan.MinY=0;
  506.           Buf->MaxOScan.MaxX=736;
  507.           Buf->MaxOScan.MaxY=283;
  508.           Buf->VideoOScan.MinX=0;
  509.           Buf->VideoOScan.MinY=0;
  510.           Buf->VideoOScan.MaxX=724;
  511.           Buf->VideoOScan.MaxY=283;
  512.           Buf->TxtOScan.MinX=0;
  513.           Buf->TxtOScan.MinY=0;
  514.           Buf->TxtOScan.MaxX=704;
  515.           Buf->TxtOScan.MaxY=280;
  516.           Buf->StdOScan.MinX=0;
  517.           Buf->StdOScan.MinY=0;
  518.           Buf->StdOScan.MaxX=704;
  519.           Buf->StdOScan.MaxY=280;
  520.           Ret=sizeof(struct DimensionInfo);
  521.         }
  522.         break;
  523.  
  524.       //case DTAG_MNTR:
  525.       //  break;
  526.  
  527.       case DTAG_NAME:
  528.         if(size >= sizeof(struct NameInfo))
  529.         {
  530.           struct NameInfo *Buf=(struct NameInfo *)buf;
  531.           memset(Buf,0,sizeof(struct NameInfo));
  532.           strcpy(Buf->Name,"PAL:HighRes");
  533.           Ret=sizeof(struct NameInfo);
  534.         }
  535.         break;
  536.     }
  537.     return( Ret );
  538.   }
  539.  
  540. /*MIC*/ LONG GetVPModeID( struct ViewPort *vp )
  541.   { return( 0x8000 ); }
  542.  
  543. /*MIC*/ ULONG TextFit(struct RastPort *rp,STRPTR string, ULONG length, struct TextExtent *textextent, struct TextExtent *rectextent, LONG direction, ULONG rectwidth, ULONG recthight)
  544.   {
  545.     struct pOS_TextDim TextDim;
  546.     TextDim.td_MaxWidth=rectextent ? rectextent->te_Width : rectwidth;
  547.     pOS_CalcTextDim((pOS_RastPort*)rp,string,length,&TextDim,0);
  548.  
  549.     textextent->te_Width=pOS_TextLength((struct pOS_RastPort*)rp,string,length);
  550.     textextent->te_Height=rp->Font->tf_YSize;
  551.     textextent->te_Extend.MinX=0;
  552.     textextent->te_Extend.MinY=0;
  553.     textextent->te_Extend.MaxX=TextDim.td_UsedWidth;
  554.     textextent->te_Extend.MaxY=textextent->te_Height;
  555.  
  556.     return( TextDim.td_UsedNumChars );
  557.   }
  558.  
  559. /*MIC*/ WORD TextExtent(struct RastPort *rp, STRPTR string, LONG length, struct TextExtent *textextent)
  560.   {
  561.     struct pOS_TextDim TextDim;
  562.     TextDim.td_MaxWidth=32000;
  563.     pOS_CalcTextDim((pOS_RastPort*)rp,string,length,&TextDim,0);
  564.  
  565.     textextent->te_Width=pOS_TextLength((struct pOS_RastPort*)rp,string,length);
  566.     textextent->te_Height=rp->Font->tf_YSize;
  567.     textextent->te_Extend.MinX=0;
  568.     textextent->te_Extend.MinY=0;
  569.     textextent->te_Extend.MaxX=TextDim.td_UsedWidth;
  570.     textextent->te_Extend.MaxY=textextent->te_Height;
  571.  
  572.     return( 0 );   /* Funktion wird als VOID beschrieben !! */
  573.   }
  574.  
  575. ULONG GetAPen( struct RastPort *rp )
  576.   {
  577.     ULONG Res;
  578.     pOS_GetRastPort((pOS_RastPort*)rp,
  579.        GFXTAG_APen, (ULONG)&Res,
  580.        TAG_END);
  581.     return(Res);
  582.   }
  583.  
  584. ULONG GetBPen( struct RastPort *rp )
  585.   {
  586.     ULONG Res;
  587.     pOS_GetRastPort((pOS_RastPort*)rp,
  588.        GFXTAG_BPen, (ULONG)&Res,
  589.        TAG_END);
  590.     return(Res);
  591.   }
  592.  
  593. ULONG GetOutlinePen( struct RastPort *rp )
  594.   {
  595.     ULONG Res;
  596.     pOS_GetRastPort((pOS_RastPort*)rp,
  597.        GFXTAG_OPen, (ULONG)&Res,
  598.        TAG_END);
  599.     return(Res);
  600.   }
  601.  
  602. void SetRGB4(struct ViewPort *vp,ULONG index,ULONG r,ULONG g,ULONG b)
  603.   {
  604.     struct pOS_RColor RC;
  605.     RC.rc_U.rc_E.rcue_A=255;     RC.rc_U.rc_E.rcue_R=r*16;
  606.     RC.rc_U.rc_E.rcue_G=g*16;    RC.rc_U.rc_E.rcue_B=b*16;
  607.     pOS_SetColor((APTR)GetColorMapViewPort(vp),index,&RC,1);
  608.     pOS_DisplayColorMap((APTR)GetColorMapViewPort(vp),DISCOLF_Always);
  609.   }
  610.  
  611. ULONG GetRGB4( struct ColorMap *colorMap, long entry )
  612.   {
  613.     struct pOS_RColor RC;
  614.     pOS_GetColor((APTR)colorMap,entry,&RC,1);
  615.     RC.rc_U.rc_E.rcue_R>>=4; RC.rc_U.rc_E.rcue_G>>=4; RC.rc_U.rc_E.rcue_B>>=4;
  616.     return( (RC.rc_U.rc_E.rcue_R<<8) | (RC.rc_U.rc_E.rcue_G<<4) | RC.rc_U.rc_E.rcue_B);
  617.   }
  618.  
  619. void LoadRGB4( struct ViewPort *vp, UWORD *colors, long count )
  620.   {
  621.     struct pOS_RColor RC;
  622.     ULONG i;
  623.  
  624.     for(i=0; i<count; ++i,++colors) {
  625.       RC.rc_U.rc_E.rcue_A=255;
  626.       RC.rc_U.rc_E.rcue_R=((colors[0]>>8) & 0x0f) * 16;
  627.       RC.rc_U.rc_E.rcue_G=((colors[0]>>4) & 0x0f) * 16;
  628.       RC.rc_U.rc_E.rcue_B=((colors[0]>>0) & 0x0f) * 16;
  629.       pOS_SetColor((APTR)GetColorMapViewPort(vp),i,&RC,1);
  630.     }
  631.     pOS_DisplayColorMap((APTR)GetColorMapViewPort(vp),DISCOLF_Always);
  632.   }
  633.  
  634. LONG WritePixelArray8(struct RastPort* rp,ULONG x1,ULONG y1,ULONG x2,ULONG y2,
  635.                       UBYTE* datas,struct RastPort* dummy)
  636.   {
  637.     ULONG Width=dummy->BitMap->BytesPerRow*8, Height=y2-y1+1;
  638.     pOS_StdChunky8GfxMap GfxMap={NULL,0,0, Width,Height,GFXMAPTYP_StdChunky8};
  639.     GfxMap.ckgm_Chunky=datas;
  640.  
  641.     pOS_WriteStdGfxMapRastPort(&GfxMap.ckgm_Gfx,0,0,
  642.          (struct pOS_RastPort*)rp,x1,y1,x2-x1+1,Height, 0);
  643.     return(0);
  644.   }
  645.  
  646. LONG WritePixelLine8(struct RastPort* rp,ULONG x1,ULONG y1,ULONG width,
  647.                      UBYTE* datas,struct RastPort* dummy)
  648.   {
  649.     ULONG Width=dummy->BitMap->BytesPerRow*8;
  650.     pOS_StdChunky8GfxMap GfxMap={NULL,0,0, Width,1,GFXMAPTYP_StdChunky8};
  651.     GfxMap.ckgm_Chunky=datas;
  652.  
  653.     pOS_WriteStdGfxMapRastPort(&GfxMap.ckgm_Gfx,0,0,
  654.          (struct pOS_RastPort*)rp,x1,y1,width,1, 0);
  655.     return(0);
  656.   }
  657.  
  658. void WriteChunkyPixels(struct RastPort* rp,ULONG x1,ULONG y1,
  659.                        ULONG x2,ULONG y2,UBYTE* datas,long bpr)
  660.   {
  661.     ULONG Width=bpr*8, Height=y2-y1+1;
  662.     pOS_StdChunky8GfxMap GfxMap={NULL,0,0, Width,Height,GFXMAPTYP_StdChunky8};
  663.     GfxMap.ckgm_Chunky=datas;
  664.  
  665.     pOS_WriteStdGfxMapRastPort(&GfxMap.ckgm_Gfx,0,0,
  666.          (struct pOS_RastPort*)rp,x1,y1,x2-x1+1,Height, 0);
  667.   }
  668.  
  669.  
  670.  
  671. #ifdef __IGNORE_NOT_SUPPORTED__
  672.  
  673.  
  674. ULONG GetDrMd( struct RastPort *rp )
  675. {return(0);}
  676.  
  677.  
  678. void LoadRGB32( struct ViewPort *vp, ULONG *table )
  679. {}
  680.  
  681. void ClearEOL( struct RastPort *rp )
  682. {}
  683. void ClearScreen( struct RastPort *rp )
  684. {}
  685. void AddBob( struct Bob *bob, struct RastPort *rp )
  686. {}
  687. void AddVSprite( struct VSprite *vSprite, struct RastPort *rp )
  688. {}
  689. void DoCollision( struct RastPort *rp )
  690. {}
  691. void DrawGList( struct RastPort *rp, struct ViewPort *vp )
  692. {}
  693. void InitGels(struct VSprite*,struct VSprite*,struct GelsInfo*)
  694. {}
  695. void InitMasks( struct VSprite *vSprite )
  696. {}
  697. void RemIBob( struct Bob *bob, struct RastPort *rp, struct ViewPort *vp )
  698. {}
  699. void RemVSprite( struct VSprite *vSprite )
  700. {}
  701. void SetCollision(ULONG num,APTR,struct GelsInfo*)
  702. {}
  703. void SortGList( struct RastPort *rp )
  704. {}
  705. void AddAnimOb(struct AnimOb*,struct AnimOb**,struct RastPort*)
  706. {}
  707. void Animate( struct AnimOb **anKey, struct RastPort *rp )
  708. {}
  709. BOOL GetGBuffers( struct AnimOb *anOb, struct RastPort *rp, long flag )
  710. {return(0);}
  711. void InitGMasks( struct AnimOb *anOb )
  712. {}
  713. void DrawEllipse(struct RastPort *rp,long xCenter,long yCenter,long a,long b)
  714. {}
  715. LONG AreaEllipse(struct RastPort *rp,long xCenter,long yCenter,long a,long b)
  716. {return(0);}
  717. void InitVPort( struct ViewPort *vp )
  718. {}
  719. ULONG MrgCop( struct View *view )
  720. {return(0);}
  721. ULONG MakeVPort( struct View *view, struct ViewPort *vp )
  722. {return(0);}
  723. void LoadView( struct View *view )
  724. {}
  725. void WaitBlit( void )
  726. {}
  727. LONG AreaMove( struct RastPort *rp, long x, long y )
  728. {return(0);}
  729. LONG AreaDraw( struct RastPort *rp, long x, long y )
  730. {return(0);}
  731. LONG AreaEnd( struct RastPort *rp )
  732. {return(0);}
  733. void WaitTOF( void )
  734. {}
  735. void QBlit( struct bltnode *blit )
  736. {}
  737. void InitArea( struct AreaInfo *areaInfo, APTR vectorBuffer,long maxVectors )
  738. {}
  739. void QBSBlit( struct bltnode *blit )
  740. {}
  741. void BltClear( PLANEPTR memBlock, unsigned long byteCount,ULONG flags )
  742. {}
  743. BOOL Flood( struct RastPort *rp, unsigned long mode, long x, long y )
  744. {return(0);}
  745. void InitView( struct View *view )
  746. {}
  747. void CBump( struct UCopList *copList )
  748. {}
  749. void CMove( struct UCopList *copList, APTR destination, long data )
  750. {}
  751. void CWait( struct UCopList *copList, long v, long h )
  752. {}
  753. LONG VBeamPos( void )
  754. {return(0);}
  755. void WaitBOVP( struct ViewPort *vp )
  756. {}
  757. WORD GetSprite( struct SimpleSprite *sprite, long num )
  758. {return(0);}
  759. void FreeSprite( long num )
  760. {}
  761. void ChangeSprite( struct ViewPort*,struct SimpleSprite*,PLANEPTR)
  762. {}
  763. void MoveSprite(struct ViewPort*,struct SimpleSprite*,long x,long y)
  764. {}
  765. void OwnBlitter( void )
  766. {}
  767. void DisownBlitter( void )
  768. {}
  769. struct TmpRas *InitTmpRas(struct TmpRas*,PLANEPTR buffer,long size)
  770. {return(0);}
  771. void AskFont( struct RastPort *rp, struct TextAttr *textAttr )
  772. {}
  773. PLANEPTR AllocRaster( unsigned long width, unsigned long height )
  774. {return(0);}
  775. void FreeRaster( PLANEPTR p, unsigned long width, unsigned long height )
  776. {}
  777. void FreeVPortCopLists( struct ViewPort *vp )
  778. {}
  779. void FreeCopList( struct CopList *copList )
  780. {}
  781. void FreeCprList( struct cprlist *cprList )
  782. {}
  783. void ScrollVPort( struct ViewPort *vp )
  784. {}
  785. struct CopList *UCopperListInit( struct UCopList *uCopList, long n )
  786. {return(0);}
  787. void FreeGBuffers( struct AnimOb *anOb, struct RastPort *rp, long flag )
  788. {}
  789. APTR GfxNew( unsigned long gfxNodeType )
  790. {return(0);}
  791. void GfxFree( APTR gfxNodePtr )
  792. {}
  793. void GfxAssociate( APTR associateNode, APTR gfxNodePtr )
  794. {}
  795. void BitMapScale( struct BitScaleArgs *bitScaleArgs )
  796. {}
  797. UWORD ScalerDiv(ULONG factor,ULONG numerator,ULONG denominator )
  798. {return(0);}
  799. APTR GfxLookUp( APTR associateNode )
  800. {return(0);}
  801. BOOL VideoControl( struct ColorMap *colorMap, struct TagItem *tagarray )
  802. {return(0);}
  803. BOOL VideoControlTags( struct ColorMap *colorMap,ULONG tag1Type,... )
  804. {return(0);}
  805. struct MonitorSpec *OpenMonitor( STRPTR monitorName,ULONG displayID )
  806. {return(0);}
  807. BOOL CloseMonitor( struct MonitorSpec *monitorSpec )
  808. {return(0);}
  809. APTR FindDisplayInfo( unsigned long displayID )
  810. {return(0);}
  811. ULONG NextDisplayInfo( unsigned long displayID )
  812. {return(0);}
  813. void FontExtent( struct TextFont *font, struct TextExtent *fontExtent )
  814. {}
  815. LONG ReadPixelLine8(struct RastPort*,ULONG,ULONG,ULONG,UBYTE*,struct RastPort*)
  816. {return(0);}
  817. LONG ReadPixelArray8(struct RastPort*,ULONG,ULONG,ULONG,ULONG,UBYTE*,struct RastPort*)
  818. {return(0);}
  819. LONG ModeNotAvailable( unsigned long modeID )
  820. {return(0);}
  821. WORD WeighTAMatch(struct TextAttr*,struct TextAttr*,struct TagItem*)
  822. {return(0);}
  823. WORD WeighTAMatchTags(struct TextAttr*,struct TextAttr*,ULONG, ... )
  824. {return(0);}
  825. ULONG ExtendFont( struct TextFont *font, struct TagItem *fontTags )
  826. {return(0);}
  827. ULONG ExtendFontTags( struct TextFont *font, unsigned long tag1Type, ... )
  828. {return(0);}
  829. void StripFont( struct TextFont *font )
  830. {}
  831. UWORD CalcIVG( struct View *v, struct ViewPort *vp )
  832. {return(0);}
  833. LONG AttachPalExtra( struct ColorMap *cm, struct ViewPort *vp )
  834. {return(0);}
  835. ULONG SetChipRev( unsigned long want )
  836. {return(0);}
  837. LONG GetExtSpriteA( struct ExtSprite *ss, struct TagItem *tags )
  838. {return(0);}
  839. LONG GetExtSprite( struct ExtSprite *ss, unsigned long tag1Type, ... )
  840. {return(0);}
  841. ULONG CoerceMode( struct ViewPort *vp,ULONG monitorid,ULONG flags )
  842. {return(0);}
  843. void ChangeVPBitMap(struct ViewPort *vp,struct BitMap *bm,struct DBufInfo *db)
  844. {}
  845. struct DBufInfo *AllocDBufInfo( struct ViewPort *vp )
  846. {return(0);}
  847. void FreeDBufInfo( struct DBufInfo *dbi )
  848. {}
  849. ULONG SetWriteMask( struct RastPort *rp, unsigned long msk )
  850. {return(0);}
  851. void SetMaxPen( struct RastPort *rp, unsigned long maxpen )
  852. {}
  853. LONG FindColor( struct ColorMap *cm,ULONG r,ULONG g,ULONG b,long maxcolor )
  854. {return(0);}
  855. struct ExtSprite *AllocSpriteDataA( struct BitMap *bm, struct TagItem *tags )
  856. {return(0);}
  857. struct ExtSprite *AllocSpriteData( struct BitMap *bm,ULONG tag1Type,... )
  858. {return(0);}
  859. LONG ChangeExtSpriteA(struct ViewPort*,struct ExtSprite*,struct ExtSprite*,struct TagItem*)
  860. {return(0);}
  861. LONG ChangeExtSprite(struct ViewPort*,struct ExtSprite*,struct ExtSprite*,ULONG tag1Type, ... )
  862. {return(0);}
  863. void FreeSpriteData( struct ExtSprite *sp )
  864. {}
  865. ULONG BestModeIDA( struct TagItem *tags )
  866. {return(0);}
  867. ULONG BestModeID( unsigned long tag1Type, ... )
  868. {return(0);}
  869.  
  870. BOOL XorRegionRegion( struct Region *srcRegion, struct Region *destRegion )
  871. {return(0);}
  872. //  { return(pOS_XorRegionRegion((pOS_Region*)srcRegion,(pOS_Region*)destRegion));}
  873.  
  874. #endif  /** __IGNORE_NOT_SUPPORTED__ **/
  875.  
  876.  
  877.  
  878. #endif
  879.