home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 109 / EnigmaAmiga109CD.iso / software / utilities / rgfx-dt35 / source / dispatcher.c next >
Encoding:
C/C++ Source or Header  |  2000-01-31  |  15.0 KB  |  648 lines
  1. #include <clib/alib_protos.h>
  2. #include <pragma/datatypes_lib.h>
  3. #include <pragma/dos_lib.h>
  4. #include <pragma/exec_lib.h>
  5. #include <pragma/graphics_lib.h>
  6. #include <pragma/iffparse_lib.h>
  7. #include <pragma/intuition_lib.h>
  8. #include <pragma/utility_lib.h>
  9. #include <pragma/xpkmaster_lib.h>
  10. #include <datatypes/pictureclass.h>
  11. #include <exec/memory.h>
  12. #include <intuition/icclass.h>
  13. #include <string.h>
  14. #include "class.h"
  15. #include "rgfx.h"
  16.  
  17. struct Arg1
  18. {
  19. char *xpk;
  20. long *xpkmode;
  21. char *password;
  22. };
  23.  
  24. ULONG SaveRGFX(IClass *cl,Object *obj,dtWrite *msg);
  25.  
  26. static long iff2dos[]=
  27. {
  28. 0,
  29. 0,
  30. DTERROR_INVALID_DATA,
  31. ERROR_NO_FREE_STORE,
  32. ERROR_SEEK_ERROR,
  33. ERROR_SEEK_ERROR,
  34. ERROR_SEEK_ERROR,
  35. DTERROR_INVALID_DATA,
  36. DTERROR_INVALID_DATA,
  37. ERROR_OBJECT_WRONG_TYPE,
  38. ERROR_REQUIRED_ARG_MISSING,
  39. 0xDEADDEAD
  40. };
  41.  
  42. static long chunks[]=
  43. {
  44. ID_RGFX,ID_RGHD,
  45. ID_RGFX,ID_RSCM,
  46. ID_RGFX,ID_RCOL,
  47. ID_RGFX,ID_NAME,
  48. ID_RGFX,ID_AUTH,
  49. ID_RGFX,ID_ANNO,
  50. ID_RGFX,ID_Copyright,
  51. ID_RGFX,ID_FVER
  52. };
  53.  
  54. void ReadPrefs(Data *data)
  55. {
  56. char *var;
  57. strcpy(data->xpk,"NUKE");
  58. data->xpkmode=100;
  59. if(data->password)
  60.     {
  61.     FreeVec(data->password);
  62.     data->password=0;
  63.     }
  64. if(var=(char *)AllocVec(256,0))
  65.     {
  66.     if(GetVar("ENV:DataTypes/rgfx.prefs",var,256,LV_VAR|GVF_GLOBAL_ONLY)>=0)
  67.         {
  68.         RDArgs *rdargs;
  69.       if(rdargs=(RDArgs *)AllocDosObject(DOS_RDARGS,0))
  70.             {
  71.             RDArgs *args;
  72.             Arg1 para;
  73.             rdargs->RDA_Source.CS_Buffer=var;
  74.             rdargs->RDA_Source.CS_Length=strlen(var);
  75.             rdargs->RDA_Source.CS_CurChr=0;
  76.             memset(¶,0,sizeof(Arg1));
  77.             if(args=ReadArgs("XPK/A,XPKMODE/A/N,PASSWORD",(long *)¶,rdargs))
  78.                 {
  79.                 strncpy(data->xpk,para.xpk,4);
  80.                 data->xpk[4]=0;
  81.                 data->xpkmode=*para.xpkmode;
  82.                 if(data->xpkmode<0) data->xpkmode=0;
  83.                 else if(data->xpkmode>100) data->xpkmode=100;
  84.                 if(para.password)
  85.                     {
  86.                     if(data->password=(char *)AllocVec(strlen(para.password)+1,MEMF_CLEAR)) strcpy(data->password,para.password);
  87.                     }
  88.                 FreeArgs(args);
  89.                 }
  90.             FreeDosObject(DOS_RDARGS,rdargs);
  91.             }
  92.         }
  93.     FreeVec(var);
  94.     }
  95. }
  96.  
  97. ULONG Colors2DT(Object *obj,UBYTE *color)
  98. {
  99. UBYTE *cr;
  100. ULONG *cregs,i,num,error=0;
  101. GetDTAttrs(obj,PDTA_NumColors,&num,PDTA_ColorRegisters,&cr,PDTA_CRegs,&cregs,TAG_END);
  102. if(cr&&cregs)
  103.     {
  104.     for(i=0;i<num;i++,cr+=3,cregs+=3,color+=4)
  105.         {
  106.         cr[0]=color[1];
  107.         cr[1]=color[2];
  108.         cr[2]=color[3];
  109.         cregs[0]=cr[0]<<24;
  110.         cregs[1]=cr[1]<<24;
  111.         cregs[2]=cr[2]<<24;
  112.         }
  113.     }
  114. else error=ERROR_NO_FREE_STORE;
  115. return error;
  116. }
  117.  
  118. static void GetRGHD(Object *obj,RGHD *rh,BitMapHeader *bh,Data *data)
  119. {
  120. bh->bmh_Left=rh->rgfx_LeftEdge;
  121. bh->bmh_Top=rh->rgfx_TopEdge;
  122. bh->bmh_Width=rh->rgfx_Width;
  123. bh->bmh_Height=rh->rgfx_Height;
  124. bh->bmh_PageWidth=rh->rgfx_PageWidth?rh->rgfx_PageWidth:bh->bmh_Width;
  125. bh->bmh_PageHeight=rh->rgfx_PageHeight?rh->rgfx_PageHeight:bh->bmh_Height;
  126. bh->bmh_Depth=rh->rgfx_Depth;
  127. bh->bmh_Compression=cmpByteRun1;
  128. bh->bmh_XAspect=rh->rgfx_XAspect;
  129. bh->bmh_YAspect=rh->rgfx_YAspect;
  130. }
  131.  
  132. static ULONG GetRSCM(Object *obj,IFFHandle *iff,BitMapHeader *bh,Data *data,ULONG rgfxdepth)
  133. {
  134. ULONG mode=0,numc=0;
  135. StoredProperty *sp;
  136. mode=INVALID_ID;
  137. if(sp=FindProp(iff,ID_RGFX,ID_RSCM))
  138.     {
  139.     RSCM *rscm=(RSCM *)sp->sp_Data;
  140.     if(!ModeNotAvailable(rscm->rscm_AGA))
  141.         {
  142.         ULONG dipf=0;
  143.         if(rscm->rscm_AGA&HAM_KEY)
  144.             {
  145.             numc=(bh->bmh_Depth==8)?64:16;
  146.             dipf=DIPF_IS_HAM;
  147.             }
  148.         else if(rscm->rscm_AGA&EXTRAHALFBRITE_KEY)
  149.             {
  150.             numc=32;
  151.             dipf=DIPF_IS_EXTRAHALFBRITE;
  152.             }
  153.         if(dipf) mode=BestModeID(
  154.         BIDTAG_NominalWidth,bh->bmh_PageWidth,BIDTAG_NominalHeight,bh->bmh_PageHeight,
  155.         BIDTAG_DesiredWidth,bh->bmh_Width,BIDTAG_DesiredHeight,bh->bmh_Height,BIDTAG_Depth,bh->bmh_Depth,
  156.         BIDTAG_DIPFMustHave,dipf,BIDTAG_DIPFMustNotHave,DIPF_IS_DUALPF|DIPF_IS_PF2PRI,TAG_END);
  157.         }
  158.     }
  159. if(mode==INVALID_ID)
  160.     {
  161.     mode=BestModeID(
  162.     BIDTAG_NominalWidth,bh->bmh_PageWidth,BIDTAG_NominalHeight,bh->bmh_PageHeight,
  163.     BIDTAG_DesiredWidth,bh->bmh_Width,BIDTAG_DesiredHeight,bh->bmh_Height,
  164.     BIDTAG_Depth,bh->bmh_Depth,
  165.     BIDTAG_DIPFMustNotHave,DIPF_IS_DUALPF|DIPF_IS_PF2PRI|DIPF_IS_HAM|DIPF_IS_EXTRAHALFBRITE,TAG_END);
  166.     numc=1<<bh->bmh_Depth;
  167.     }
  168. if(mode!=INVALID_ID)
  169.     {
  170.     SetDTAttrs(obj,0,0,PDTA_ModeID,mode,TAG_END);
  171.     if(numc) SetDTAttrs(obj,0,0,PDTA_NumColors,numc,TAG_END);
  172.     }
  173. return mode;
  174. }
  175.  
  176. static ULONG GetRCOL(Object *obj,IFFHandle *iff,RGHD *rh)
  177. {
  178. ULONG error=0;
  179. if(rh->rgfx_Depth<=8)
  180.     {
  181.     StoredProperty *sp;
  182.     if(sp=FindProp(iff,ID_RGFX,ID_RCOL))
  183.         {
  184.         RCOL *rcol=(RCOL *)sp->sp_Data;
  185.         ULONG n,*cregs;
  186.         UBYTE *cr,*p;
  187.         GetDTAttrs(obj,PDTA_NumColors,&n,PDTA_ColorRegisters,&cr,PDTA_CRegs,&cregs,TAG_END);
  188.         if(cr&&cregs)
  189.             {
  190.             ULONG i;
  191.             n*=3;
  192.             for(i=0,p=rcol->rcol_Colors[0];i<n;i++,p++,cr++,cregs++)
  193.                 {
  194.                 *cr=*p;
  195.                 *cregs=(*p)<<24;
  196.                 }
  197.             }
  198.         else error=ERROR_NO_FREE_STORE;
  199.         }
  200.     else error=ERROR_REQUIRED_ARG_MISSING;
  201.     }
  202. return error;
  203. }
  204.  
  205. static ULONG GetBody_BP8(IFFHandle *iff,RGHD *rh,BitMap *bm,Data *data)
  206. {
  207. ULONG error=0,d;
  208. for(d=0;d<rh->rgfx_Depth;d++)
  209.     {
  210.     ULONG y;
  211.     UBYTE *pl=bm->Planes[d];
  212.     for(y=0;y<rh->rgfx_Height;y++,pl+=bm->BytesPerRow)
  213.         {
  214.         long err;
  215.         if((err=ReadChunkBytes(iff,pl,rh->rgfx_BytesPerLine)<0))
  216.             {
  217.             error=iff2dos[-err];
  218.             break;
  219.             }
  220.         }
  221.     }
  222. return error;
  223. }
  224.  
  225. static ULONG GetBody_BC8(IFFHandle *iff,RGHD *rh,BitMap *bm,Data *data)
  226. {
  227. ULONG error=0;
  228. long err;
  229. UBYTE *pix;
  230. RastPort rp;
  231. if(pix=(UBYTE *)AllocVec(rh->rgfx_Width*rh->rgfx_Height,0))
  232.     {
  233.     if((err=ReadChunkBytes(iff,pix,rh->rgfx_Width*rh->rgfx_Height))<0) error=iff2dos[-err];
  234.     else
  235.         {
  236.         InitRastPort(&rp);
  237.         rp.BitMap=bm;
  238.         WriteChunkyPixels(&rp,0,0,rh->rgfx_Width-1,rh->rgfx_Height-1,pix,rh->rgfx_Width);
  239.         }
  240.     FreeVec(pix);
  241.     }
  242. else
  243.     {
  244.     if(pix=(UBYTE *)AllocVec(rh->rgfx_Width,0))
  245.         {
  246.         ULONG y;
  247.         InitRastPort(&rp);
  248.         rp.BitMap=bm;
  249.         for(y=0;y<rh->rgfx_Height;y++)
  250.             {
  251.             long err;
  252.             if((err=ReadChunkBytes(iff,pix,rh->rgfx_Width))<0)
  253.                 {
  254.                 error=iff2dos[-err];
  255.                 break;
  256.                 }
  257.             WriteChunkyPixels(&rp,0,y,rh->rgfx_Width-1,1,pix,rh->rgfx_Width);
  258.             }
  259.         FreeVec(pix);
  260.         }
  261.     else error=ERROR_NO_FREE_STORE;
  262.     }
  263. return error;
  264. }
  265.  
  266. static ULONG GetBody_RGB_V43(Object *obj,IFFHandle *iff,RGHD *rh,Data *data)
  267. {
  268. ULONG error=0;
  269. UBYTE *pix;
  270. long err;
  271. if(pix=(UBYTE *)AllocVec(rh->rgfx_BytesPerLine*rh->rgfx_Height,0))
  272.     {
  273.     if((err=ReadChunkBytes(iff,pix,rh->rgfx_BytesPerLine*rh->rgfx_Height))<0) error=iff2dos[-err];
  274.     else DoMethod(obj,PDTM_WRITEPIXELARRAY,pix,PBPAFMT_RGB,rh->rgfx_BytesPerLine,0,0,rh->rgfx_Width,rh->rgfx_Height);
  275.     FreeVec(pix);
  276.     }
  277. else if(pix=(UBYTE *)AllocVec(rh->rgfx_BytesPerLine,0))
  278.     {
  279.     ULONG y;
  280.     for(y=0;y<rh->rgfx_Height;y++)
  281.         {
  282.         if((err=ReadChunkBytes(iff,pix,rh->rgfx_BytesPerLine))<0)
  283.             {
  284.             error=iff2dos[-err];
  285.             break;
  286.             }
  287.         DoMethod(obj,PDTM_WRITEPIXELARRAY,pix,PBPAFMT_RGB,rh->rgfx_BytesPerLine,0,y,rh->rgfx_Width,1);
  288.         }
  289.     FreeVec(pix);
  290.     }
  291. else error=ERROR_NO_FREE_STORE;
  292. return error;
  293. }
  294.  
  295. static ULONG GetBody_XPKBP8(IFFHandle *iff,RGHD *rh,BitMap *bm,Data *data)
  296. {
  297. ULONG error=0,d,y;
  298. XpkFib *fib;
  299. UBYTE *mem,*pl;
  300. if(!XpkUnpackTags(XPK_InFH,iff->iff_Stream,XPK_GetOutBuf,&mem,XPK_GetOutBufLen,&y,TAG_END))
  301.     {
  302.     UBYTE *p=mem;
  303.     for(d=0;d<rh->rgfx_Depth;d++)
  304.         {
  305.         pl=bm->Planes[d];
  306.         for(y=0;y<rh->rgfx_Height;y++,pl+=bm->BytesPerRow,p+=rh->rgfx_BytesPerLine) CopyMem(p,pl,bm->BytesPerRow);
  307.         }
  308.     FreeMem(mem,y);
  309.     }
  310. else if(!XpkOpenTags(&fib,XPK_InFH,iff->iff_Stream,TAG_END))
  311.     {
  312.     if(mem=(UBYTE *)AllocVec(fib->xf_NLen,0))
  313.         {
  314.         long p=-1,clen=-1;
  315.         for(d=0;d<rh->rgfx_Depth;d++)
  316.             {
  317.             pl=bm->Planes[d];
  318.             for(y=0;y<rh->rgfx_Height;y++,pl+=bm->BytesPerRow)
  319.                 {
  320.                 ULONG x;
  321.                 for(x=0;x<rh->rgfx_BytesPerLine;x++)
  322.                     {
  323.                     if(p>=clen)
  324.                         {
  325.                         if((clen=XpkRead(fib,mem,fib->xf_NLen))<0)
  326.                             {
  327.                             error=DTERROR_INVALID_DATA;
  328.                             y=rh->rgfx_Height;
  329.                             d=rh->rgfx_Depth;
  330.                             break;
  331.                             }
  332.                         p=0;
  333.                         }
  334.                     pl[x]=mem[p];
  335.                     p++;
  336.                     }
  337.                 }
  338.             }
  339.         FreeVec(mem);
  340.         }
  341.     else error=ERROR_NO_FREE_STORE;
  342.     XpkClose(fib);
  343.     }
  344. else error=DTERROR_INVALID_DATA;
  345. return error;
  346. }
  347.  
  348. static ULONG GetBody_XPKBC8(IFFHandle *iff,RGHD *rh,BitMap *bm,Data *data)
  349. {
  350. ULONG error=0,pixlen;
  351. UBYTE *pix;
  352. RastPort rp;
  353. if(!XpkUnpackTags(XPK_InFH,iff->iff_Stream,XPK_GetOutBuf,&pix,XPK_GetOutBufLen,&pixlen,TAG_END))
  354.     {
  355.     InitRastPort(&rp);
  356.     rp.BitMap=bm;
  357.     WriteChunkyPixels(&rp,0,0,rh->rgfx_Width-1,rh->rgfx_Height-1,pix,rh->rgfx_Width);
  358.     FreeMem(pix,pixlen);
  359.     }
  360. else
  361.     {
  362.     ULONG y;
  363.     XpkFib *fib;
  364.     if(!XpkOpenTags(&fib,XPK_InFH,iff->iff_Stream,TAG_END))
  365.         {
  366.         UBYTE *mem;
  367.         if(mem=(UBYTE *)AllocVec(fib->xf_NLen,0))
  368.             {
  369.             if(pix=(UBYTE *)AllocVec(rh->rgfx_Width,0))
  370.                 {
  371.                 long p=-1,clen=-1;
  372.                 InitRastPort(&rp);
  373.                 rp.BitMap=bm;
  374.                 for(y=0;y<rh->rgfx_Height;y++)
  375.                     {
  376.                     ULONG x;
  377.                     for(x=0;x<rh->rgfx_Width;x++)
  378.                         {
  379.                         if(p>=clen)
  380.                             {
  381.                             if((clen=XpkRead(fib,mem,fib->xf_NLen))<0)
  382.                                 {
  383.                                 error=DTERROR_INVALID_DATA;
  384.                                 y=rh->rgfx_Height;
  385.                                 break;
  386.                                 }
  387.                             p=0;
  388.                             }
  389.                         pix[x]=mem[p];
  390.                         p++;
  391.                         }
  392.                     WriteChunkyPixels(&rp,0,y,rh->rgfx_Width-1,1,pix,rh->rgfx_Width);
  393.                     }
  394.                 FreeVec(pix);
  395.                 }
  396.             else error=ERROR_NO_FREE_STORE;
  397.             FreeVec(mem);
  398.             }
  399.         else error=ERROR_NO_FREE_STORE;
  400.         XpkClose(fib);
  401.         }
  402.     else error=DTERROR_INVALID_DATA;
  403.     }
  404. return error;
  405. }
  406.  
  407. static ULONG GetBody_XPKRGB_V43(Object *obj,IFFHandle *iff,RGHD *rh,Data *data)
  408. {
  409. ULONG error=0,pixlen;
  410. XpkFib *fib;
  411. UBYTE *pix;
  412. if(!XpkUnpackTags(XPK_InFH,iff->iff_Stream,XPK_GetOutBuf,&pix,XPK_GetOutBufLen,&pixlen,TAG_END))
  413.     {
  414.     DoMethod(obj,PDTM_WRITEPIXELARRAY,pix,PBPAFMT_RGB,rh->rgfx_BytesPerLine,0,0,rh->rgfx_Width,rh->rgfx_Height);
  415.     FreeMem(pix,pixlen);
  416.     }
  417. else if(!XpkOpenTags(&fib,XPK_InFH,iff->iff_Stream,TAG_END))
  418.     {
  419.     UBYTE *mem;
  420.     if(mem=(UBYTE *)AllocVec(fib->xf_NLen,0))
  421.         {
  422.         if(pix=(UBYTE *)AllocVec(rh->rgfx_BytesPerLine,0))
  423.             {
  424.             long p=-1,clen=-1;
  425.             ULONG y;
  426.             for(y=0;y<rh->rgfx_Height;y++)
  427.                 {
  428.                 ULONG x;
  429.                 for(x=0;x<rh->rgfx_BytesPerLine;x++)
  430.                     {
  431.                     if(p>=clen)
  432.                         {
  433.                         if((clen=XpkRead(fib,mem,fib->xf_NLen))<0)
  434.                             {
  435.                             error=DTERROR_INVALID_DATA;
  436.                             y=rh->rgfx_Height;
  437.                             break;
  438.                             }
  439.                         p=0;
  440.                         }
  441.                     pix[x]=mem[p];
  442.                     p++;
  443.                     }
  444.                 DoMethod(obj,PDTM_WRITEPIXELARRAY,pix,PBPAFMT_RGB,rh->rgfx_BytesPerLine,0,y,rh->rgfx_Width,1);
  445.                 }
  446.             FreeVec(pix);
  447.             }
  448.         else error=ERROR_NO_FREE_STORE;
  449.         FreeVec(mem);
  450.         }
  451.     else error=ERROR_NO_FREE_STORE;
  452.     XpkClose(fib);
  453.     }
  454. else error=DTERROR_INVALID_DATA;
  455. return error;
  456. }
  457.  
  458. static ULONG GetPicture(IClass *cl,Object *obj)
  459. {
  460. ULONG error=0;
  461. long err;
  462. IFFHandle *iff;
  463. BitMapHeader *bh;
  464. GetDTAttrs(obj,DTA_Name,&bh,TAG_END);
  465. if(bh) SetDTAttrs(obj,0,0,DTA_ObjName,bh,TAG_END);
  466. GetDTAttrs(obj,DTA_Handle,&iff,PDTA_BitMapHeader,&bh,TAG_END);
  467. if(bh)
  468.     {
  469.     if(!iff)
  470.         {
  471.         GetDTAttrs(obj,DTA_SourceType,&err,TAG_END);
  472.         if(err!=DTST_RAM) return ERROR_REQUIRED_ARG_MISSING;
  473.         else return 0;
  474.         }
  475.     if((err=PropChunks(iff,chunks,sizeof(chunks)/(2*sizeof(long))))<0) return iff2dos[-err];
  476.     if((err=StopOnExit(iff,ID_RGFX,ID_RBOD))<0) return iff2dos[-err];
  477.     for(;;)
  478.         {
  479.         StoredProperty *sp;
  480.         if((err=ParseIFF(iff,IFFPARSE_SCAN))!=IFFERR_EOC)
  481.             {
  482.             error=iff2dos[-err];
  483.             break;
  484.             }
  485.         if(sp=FindProp(iff,ID_RGFX,ID_NAME)) SetDTAttrs(obj,0,0,DTA_ObjName,sp->sp_Data,TAG_END);
  486.         if(sp=FindProp(iff,ID_RGFX,ID_AUTH)) SetDTAttrs(obj,0,0,DTA_ObjAuthor,sp->sp_Data,TAG_END);
  487.         if(sp=FindProp(iff,ID_RGFX,ID_ANNO)) SetDTAttrs(obj,0,0,DTA_ObjAnnotation,sp->sp_Data,TAG_END);
  488.         if(sp=FindProp(iff,ID_RGFX,ID_Copyright)) SetDTAttrs(obj,0,0,DTA_ObjCopyright,sp->sp_Data,TAG_END);
  489.         if(sp=FindProp(iff,ID_RGFX,ID_FVER)) SetDTAttrs(obj,0,0,DTA_ObjVersion,sp->sp_Data,TAG_END);
  490.         if(sp=FindProp(iff,ID_RGFX,ID_RGHD))
  491.             {
  492.             RGHD *rh=(RGHD *)sp->sp_Data;
  493.             Data *data=(Data *)INST_DATA(cl,obj);
  494.             ContextNode *cn;
  495.             ReadPrefs(data);
  496.             GetRGHD(obj,rh,bh,data);
  497.             if(rh->rgfx_Depth<=8)
  498.                 {
  499.                 if(GetRSCM(obj,iff,bh,data,rh->rgfx_Depth)==INVALID_ID) break;
  500.                 }
  501.             if(error=GetRCOL(obj,iff,rh)) break;
  502.             if((cn=CurrentChunk(iff))&&(cn->cn_ID=='RBOD'))
  503.                 {
  504.                 BitMap *bm;
  505.                 switch(rh->rgfx_BitMapType)
  506.                     {
  507.                     case RMBT_BYTEPLANAR8:
  508.                         if(bm=AllocBitMap(rh->rgfx_Width,rh->rgfx_Height,rh->rgfx_Depth,BMF_CLEAR|BMF_DISPLAYABLE|BMF_STANDARD,0)) SetDTAttrs(obj,0,0,DTA_NominalHoriz,bh->bmh_Width,DTA_NominalVert,bh->bmh_Height,PDTA_BitMap,bm,TAG_END);
  509.                         else error=ERROR_NO_FREE_STORE;
  510.                         break;
  511.                     case RMBT_BYTECHUNKY8:
  512.                         if(bm=AllocBitMap(rh->rgfx_Width,rh->rgfx_Height,rh->rgfx_Depth,BMF_CLEAR|BMF_DISPLAYABLE|BMF_STANDARD,0)) SetDTAttrs(obj,0,0,DTA_NominalHoriz,bh->bmh_Width,DTA_NominalVert,bh->bmh_Height,PDTA_BitMap,bm,TAG_END);
  513.                         else error=ERROR_NO_FREE_STORE;
  514.                         break;
  515.                     case RMBT_3BYTERGB24:
  516.                         SetDTAttrs(obj,0,0,DTA_ErrorNumber,&error,DTA_NominalHoriz,bh->bmh_Width,DTA_NominalVert,bh->bmh_Height,PDTA_SourceMode,PMODE_V43,PDTA_ModeID,0,TAG_END);
  517.                         break;
  518.                     default:
  519.                         error=ERROR_NOT_IMPLEMENTED;
  520.                     }
  521.                 if(!error)
  522.                     {
  523.                     switch(rh->rgfx_Compression)
  524.                         {
  525.                         case RCMT_NOCOMPRESSION:
  526.                             switch(rh->rgfx_BitMapType)
  527.                                 {
  528.                                 case RMBT_BYTEPLANAR8:
  529.                                     error=GetBody_BP8(iff,rh,bm,data);
  530.                                     break;
  531.                                 case RMBT_BYTECHUNKY8:
  532.                                     error=GetBody_BC8(iff,rh,bm,data);
  533.                                     break;
  534.                                 case RMBT_3BYTERGB24:
  535.                                     error=GetBody_RGB_V43(obj,iff,rh,data);
  536.                                 }
  537.                             break;
  538.                         case RCMT_XPK:
  539.                             switch(rh->rgfx_BitMapType)
  540.                                 {
  541.                                 case RMBT_BYTEPLANAR8:
  542.                                     error=GetBody_XPKBP8(iff,rh,bm,data);
  543.                                     break;
  544.                                 case RMBT_BYTECHUNKY8:
  545.                                     error=GetBody_XPKBC8(iff,rh,bm,data);
  546.                                     break;
  547.                                 case RMBT_3BYTERGB24:
  548.                                     error=GetBody_XPKRGB_V43(obj,iff,rh,data);
  549.                                 }
  550.                         }
  551.                     }
  552.                 break;
  553.                 }
  554.             else error=DTERROR_INVALID_DATA;
  555.             }
  556.         else error=DTERROR_INVALID_DATA;
  557.         }
  558.     }
  559. else error=ERROR_NO_FREE_STORE;
  560. return error;
  561. }
  562.  
  563. static ULONG mNew(IClass *cl,Object *obj,opSet *msg)
  564. {
  565. TagItem *ti;
  566. if(ti=FindTagItem(DTA_SourceType,(((opSet *)msg)->ops_AttrList)))
  567.     {
  568.     if(ti->ti_Data!=DTST_FILE&&ti->ti_Data!=DTST_CLIPBOARD&&ti->ti_Data!=DTST_RAM)
  569.         {
  570.         SetIoErr(ERROR_OBJECT_WRONG_TYPE);
  571.         return 0;
  572.         }
  573.     }
  574. if(obj==(Object *)cl)
  575.     {
  576.     if(obj=(Object *)DoSuperMethodA(cl,obj,Msg(msg)))
  577.         {
  578.         ULONG error;
  579.         if(error=GetPicture(cl,obj))
  580.             {
  581.             SetIoErr(error);
  582.             CoerceMethod(cl,obj,OM_DISPOSE);
  583.             obj=0;
  584.             }
  585.         }
  586.     }
  587. else
  588.     {
  589.     SetIoErr(ERROR_NOT_IMPLEMENTED);
  590.     obj=0;
  591.     }
  592. return ULONG(obj);
  593. }
  594.  
  595. static ULONG mDispose(IClass *cl,Object *obj,Msg msg)
  596. {
  597. Data *data=(Data *)INST_DATA(cl,obj);
  598. if(data->password) FreeVec(data->password);
  599. return DoSuperMethodA(cl,obj,msg);
  600. }
  601.  
  602. static ULONG mSet(IClass *cl,Object *obj,opSet *msg)
  603. {
  604. ULONG retval;
  605. if(retval=DoSuperMethodA(cl,obj,Msg(msg)))
  606.     {
  607.     RastPort *rp;
  608.     if(rp=ObtainGIRPort(msg->ops_GInfo))
  609.         {
  610.         DoMethod(obj,GM_RENDER,msg->ops_GInfo,rp,GREDRAW_UPDATE);
  611.         ReleaseGIRPort(rp);
  612.         retval=0;
  613.         }
  614.     }
  615. return retval;
  616. }
  617.  
  618. static ULONG mWrite(IClass *cl,Object *obj,dtWrite *msg)
  619. {
  620. return (msg->dtw_Mode==DTWM_IFF)?DoSuperMethodA(cl,obj,Msg(msg)):SaveRGFX(cl,obj,msg);
  621. }
  622.  
  623. extern "C" ULONG Dispatcher(register __a0 IClass *cl,register __a2 Object *obj,register __a1 Msg msg)
  624. {
  625. ULONG retval;
  626. switch(msg->MethodID)
  627.     {
  628.     case OM_NEW:
  629.         retval=mNew(cl,obj,(opSet *)msg);
  630.         break;
  631.     case OM_DISPOSE:
  632.         retval=mDispose(cl,obj,msg);
  633.         break;
  634.     case OM_UPDATE:
  635.         if(DoMethod(obj,ICM_CHECKLOOP)) break;
  636.     case OM_SET:
  637.         retval=mSet(cl,obj,(opSet *)msg);
  638.         break;
  639.     case DTM_WRITE:
  640.         retval=mWrite(cl,obj,(dtWrite *)msg);
  641.         break;
  642.     default:
  643.         retval=DoSuperMethodA(cl,obj,msg);
  644.         }
  645. return retval;
  646. }
  647.  
  648.