home *** CD-ROM | disk | FTP | other *** search
/ The CDPD Public Domain Collection for CDTV 3 / CDPDIII.bin / pd / commodities / superdark / main / icon_data.c < prev    next >
C/C++ Source or Header  |  1993-03-21  |  10KB  |  472 lines
  1. /********************/
  2. /* File icon_data.c */
  3. /********************/
  4.  
  5. /* Function: Configuration Load and Save using ToolTypes... */
  6.  
  7. #include <ctype.h>
  8. #include <exec/types.h>
  9. #include <exec/memory.h>
  10. #include <exec/ports.h>
  11. #include <exec/execbase.h>
  12. #include <intuition/intuitionbase.h>
  13. #include <intuition/gadgetclass.h>
  14. #include <libraries/commodities.h>
  15. #include <libraries/gadtools.h>
  16. #include <workbench/startup.h>
  17. #include <workbench/icon.h>
  18. #include <workbench/workbench.h>
  19. #include <dos/dosextens.h>
  20. #include <dos/dostags.h>
  21. #include <dos/rdargs.h>
  22.  
  23. #include <clib/commodities_protos.h>
  24. #include <clib/dos_protos.h>
  25. #include <clib/exec_protos.h>
  26. #include <clib/gadtools_protos.h>
  27. #include <clib/graphics_protos.h>
  28. #include <clib/icon_protos.h>
  29. #include <clib/intuition_protos.h>
  30. #include <clib/macros.h>
  31.  
  32. #include "/includes/tom_gadget.h"
  33. #include "/includes/struct.h"
  34.  
  35. #include <string.h>
  36. #include <stdlib.h>
  37.  
  38.  
  39. char    buffer_effet[20];
  40.  
  41. #define VOID_INTERRUPT void __interrupt __saveds
  42. #define REGARGS        __regargs
  43. #define VOID_STDARGS   void __stdargs
  44. #define SIZE_VECT    100
  45.  
  46. UWORD PutChar[2] = {0x16C0,0x4E75};
  47.  
  48. extern    UBYTE    flg_debug;
  49.  
  50. /* dirty hack to avoid assembler part :-)
  51.  
  52.    16C0: move.b d0,(a3)+
  53.    4E75: rts
  54. */
  55.  
  56. VOID_STDARGS SPrintF(char *Buffer,char *FormatString,...)
  57.  
  58. {
  59.  RawDoFmt (FormatString,(APTR)((LONG *)&FormatString+1L),
  60.            (void *)PutChar,Buffer);
  61. }
  62.  
  63. /*
  64. VOID_STDARGS printf(char *FormatString,...)
  65.  
  66. {
  67.   char Buffer[256];
  68.  
  69.   RawDoFmt (FormatString,(APTR)((LONG *)&FormatString+1L),
  70.            (void *)PutChar,Buffer);
  71.     
  72. }
  73. */
  74.  
  75. char    buffer_conv[256];
  76.  
  77. /*
  78.  
  79.    "icon.library" Stuff
  80.  
  81. */
  82.  
  83. char    *convert_string(char    *p_c)
  84. {
  85.     char    *p_dest=buffer_conv;
  86.  
  87.     while(*p_c!=0){
  88.         if(*p_c!='_'){
  89.             *p_dest++=toupper(*p_c);
  90.         }
  91.         *p_c++;
  92.     }
  93.     *p_dest=0;
  94.     return(buffer_conv);
  95. }
  96. char REGARGS *YesNo(LONG Flag)
  97. {
  98.     return Flag?"YES":"NO";
  99. }
  100.  
  101. char REGARGS 
  102. *ToolTypeString(struct DiskObject *DiskObject,char *ID,
  103.                              char *Default)
  104.  
  105. {
  106.     char *String;
  107.     char    *ret;
  108.  
  109.     ret=Default;
  110.     if (DiskObject!=NULL){
  111.         if (String=FindToolType(DiskObject->do_ToolTypes,ID)){
  112.             ret=String;
  113.         }
  114.     }
  115.     return    ret;
  116. }
  117.  
  118. LONG REGARGS
  119. ToolTypeBoolean(struct DiskObject *DiskObject,char *ID,LONG Default)
  120.  
  121. {
  122.     LONG    ret;
  123.     char    *p_tool;
  124.     ret=Default;
  125.     p_tool=ToolTypeString(DiskObject,ID,"");
  126.     if(p_tool!=NULL){
  127.         if(stricmp(p_tool,YesNo(FALSE))==0){
  128.             ret=FALSE;
  129.         }else{
  130.             ret=TRUE;
  131.         }
  132.     }
  133.     return ret;
  134. }
  135.  
  136. LONG REGARGS
  137. ToolTypeLong(struct DiskObject *DiskObject,char *ID,LONG Default,
  138.                 LONG Min,LONG Max)
  139. {
  140.  char *String;
  141.  LONG ret;
  142.  
  143.  ret=Default;
  144.  if (DiskObject!=NULL){
  145.      if (String=FindToolType(DiskObject->do_ToolTypes,ID)){
  146.         LONG Value;
  147.         Value=atol(String);
  148.         if ((Value>=Min)&&(Value<=Max)){
  149.             ret=Value;
  150.         }
  151.     }
  152.   }
  153.   return(ret);
  154. }
  155.  
  156. /******************************************************* find_next() ****/
  157.  
  158. /*******************************************/
  159. /* Find the next occurence of a given char */
  160. /* in a given string.               */
  161. /*******************************************/
  162.  
  163. char    *find_next(char *pc,char val)
  164. {
  165.     while((*pc!=0)&&(*pc!=val)){
  166.         pc++;
  167.     }
  168.     if(*pc!=0){
  169.         pc++;
  170.     }
  171.     return( pc );
  172. }
  173.  
  174. /************************************************************ ahtoi() */
  175.  
  176. /**************************************/
  177. /* Convert an ascII string containing */
  178. /* an hexadecimal value in an integer */
  179. /**************************************/
  180.  
  181. ULONG    ahtoi(char    *pc)
  182. {
  183.     char    c;
  184.     ULONG    val;
  185.     val=0;
  186.     while(*pc==' ')pc++;
  187.     while(isxdigit(*pc)){
  188.         c=*pc++;
  189.         if(c>='a'){
  190.             c=c-('a'-'9')+1;
  191.         }else if(c>='A'){
  192.             c=c-('A'-'9')+1;
  193.         }
  194.         val=val*16+c-'0';
  195.     }
  196.     return (val);
  197. }
  198.  
  199. void    get_gadg(struct    tom_gadget    *p_g,struct DiskObject *DiskObject)
  200. {
  201.     char    buffer[SIZE_VECT];
  202.     char    **p_tab,*p_temp;
  203.     int    i,flg_found;
  204.     int    word1,byte1,byte2;
  205.     struct    TextAttr *p_attr;
  206.  
  207.     convert_string(p_g->GadgetText);
  208.     printd(":%s   ",buffer_conv);
  209.     switch(p_g->type_gadg){
  210.             case BUTTON:
  211.                 p_g->value=ToolTypeBoolean(DiskObject,buffer_conv,FALSE);
  212.                 break;
  213.             case CHECKBOX:
  214.                 p_g->value=ToolTypeBoolean(DiskObject,buffer_conv,p_g->value);
  215.                 printd("get_gadg:checkbox:%d\n",p_g->value);
  216.                 break;
  217.             case MX:
  218.             case CYCLE:
  219.                 (void)strcpy(buffer,ToolTypeString(DiskObject,buffer_conv,"Bof"));
  220.                 p_tab=(char **)p_g->p_data;
  221.                 i=0;
  222.                 flg_found=FALSE;
  223.                 while((*p_tab!=NULL)&&(flg_found==FALSE)){
  224.                     if(strcmp(*p_tab,buffer)==0){
  225.                         printd("Type found,%s=%d\n",*p_tab,i);
  226.                         flg_found=TRUE;
  227.                     }else{
  228.                         p_tab++;
  229.                         i++;
  230.                     }
  231.                 }
  232.                 if(flg_found==FALSE){
  233.                     i=0;
  234.                 }
  235.                 printd("mx ou cycle:string:%d\n",i);
  236.                 p_g->value=i;
  237.                 break;
  238.             case SLIDER:
  239.                 p_g->value=ToolTypeLong(DiskObject,buffer_conv,p_g->value,p_g->d1,p_g->d2);
  240.                 if(p_g->p_data!=0)(*(int *)p_g->p_data=p_g->value);
  241.                 printd("slider:%d\n",p_g->value);
  242.                 break;
  243.             case STRING:
  244.             case DATA_STRING:
  245.                 (void)strcpy(p_g->p_data,ToolTypeString(DiskObject,buffer_conv,p_g->p_data));
  246.                 printd("string:%s\n",p_g->p_data);
  247.                 break;
  248.             case    LISTVIEW:
  249.  
  250.                 /* Vu qu'a ce niveau on n'a pas encore la liste */
  251.                 /* des effets,on sauve le nom du buffer tempo.    */
  252.  
  253.                 strcpy(buffer_effet,ToolTypeString(DiskObject,buffer_conv,"Bof"));
  254.                 printd("listview:%s\n",buffer_effet);
  255.                 break;
  256.             case    OWN_GADGET:
  257.                 p_g->value=ToolTypeLong(DiskObject,buffer_conv,0L,-10000,10000);
  258.                 break;
  259.  
  260.             case SCREEN:
  261.                 strcpy(buffer_effet,ToolTypeString(DiskObject,buffer_conv,""));
  262.                 printd("screen:%s\n",buffer_effet);
  263.                 p_temp=buffer_effet;
  264.                 p_g->d1=atoi(p_temp);
  265.                 p_temp=find_next(p_temp,'x');
  266.                 p_g->d2=atoi(p_temp);
  267.                 p_temp=find_next(p_temp,'x');
  268.                 p_g->d3=atoi(p_temp);
  269.                 p_temp=find_next(p_temp,'=');
  270.                 p_g->p_data=(char *)ahtoi(p_temp);
  271.                 p_temp=find_next(p_temp,'=');
  272.                 p_g->value=atoi(p_temp);
  273.  
  274.                 printd ("Resultat:%ld x %ld x %ld ID=%lx OVSCAN=%ld",
  275.                     p_g->d1,
  276.                     p_g->d2,
  277.                     p_g->d3,
  278.                     (ULONG)p_g->p_data,
  279.                     p_g->value);
  280.                 break;
  281.             case FONT:
  282.                 strcpy(buffer_effet,ToolTypeString(DiskObject,buffer_conv,"Topaz.font 8 0 0"));
  283.                 printd("font:%s\n",buffer_effet);
  284.                 p_attr=(struct TextAttr *)p_g->p_data;
  285.                 p_temp=find_next(buffer_effet,' ');
  286.                 if(*p_temp!=0)*(p_temp-1)=0;
  287.                 strcpy(p_attr->ta_Name,buffer_effet);
  288.                 sscanf(p_temp,"%d %d %d",
  289.                         &word1,&byte1,&byte2);
  290.  
  291.                 p_attr->ta_YSize=word1;
  292.                 p_attr->ta_Style=byte1;
  293.                 p_attr->ta_Flags=byte2;
  294.  
  295.                 printd ("Resultat:%s  size %ld Style %ld flags:%ld",
  296.                     p_attr->ta_Name,word1,byte1,byte2);
  297.                 break;
  298.     }
  299. }
  300.  
  301. void
  302. LoadConfig(char *Name,struct    tom_gadget *p_gadg)
  303.  
  304. {
  305.     struct DiskObject *DiskObject;
  306.     int    i;
  307.  
  308.     if (Name){
  309.         DiskObject=GetDiskObject(Name);
  310.         if(DiskObject!=0){
  311.             i=0;
  312.             while(p_gadg[i].type_gadg!=END_LISTE){
  313.                 get_gadg(&p_gadg[i],DiskObject);
  314.                 i++;
  315.             }
  316.             FreeDiskObject (DiskObject);
  317.         }
  318.     }
  319. }
  320.  
  321. char    *add_gadg(struct    tom_gadget    *p_g,char    *vect)
  322. {
  323.     UBYTE    **p_tab;
  324.     int    num,i;
  325.     struct    Node    *node;
  326.     struct    TextAttr *p_attr;
  327.  
  328.     convert_string(p_g->GadgetText);
  329.     printd("add_gadg:%s..",buffer_conv);
  330.     switch(p_g->type_gadg){
  331.             case BUTTON:
  332.                 *vect=0;
  333.                 break;
  334.             case CHECKBOX:
  335.                 SPrintF (vect,"%s=%s",buffer_conv,YesNo(p_g->value));
  336.                 printd("Checkbox:%d ",p_g->value);
  337.                 break;
  338.             case MX:
  339.             case CYCLE:
  340.                 p_tab=(UBYTE **)p_g->p_data;
  341.                 SPrintF (vect,"%s=%s",buffer_conv,p_tab[p_g->value]);
  342.                 printd("Add gadg,MX ou cycle,resultat:%s ",p_tab[p_g->value]);
  343.                 break;
  344.             case    LISTVIEW:
  345.                 num=p_g->value;
  346.                 node=((struct List *)(p_g->p_data))->lh_Head;
  347.                 for(i=0;i<p_g->value;i++){
  348.                     if(node->ln_Succ!=NULL){
  349.                         node=node->ln_Succ;
  350.                     }
  351.                 }
  352.                 SPrintF (vect,"%s=%s",buffer_conv,node->ln_Name);
  353.                 printd("listvue,value:%d ",p_g->value);
  354.                 break;
  355.             case    OWN_GADGET:
  356.                 SPrintF (vect,"%s=%d",buffer_conv,p_g->value);
  357.                 break;
  358.             case SLIDER:
  359.                 SPrintF (vect,"%s=%ld",buffer_conv,p_g->value);
  360.                 printd("Slider,value:%d ",p_g->value);
  361.                 break;
  362.             case STRING:
  363.             case DATA_STRING:
  364.                 SPrintF (vect,"%s=%s",buffer_conv,p_g->p_data);
  365.                 printd("String,value:%s ",p_g->p_data);
  366.                 break;
  367.             case SCREEN:
  368.                 SPrintF (vect,"%s=%ld x %ld x %ld ID=%lx OVSCAN=%ld",
  369.                     buffer_conv,
  370.                     p_g->d1,
  371.                     p_g->d2,
  372.                     p_g->d3,
  373.                     (ULONG)p_g->p_data,
  374.                     p_g->value);
  375.                 printd("Screen,value:%s ",vect);
  376.                 break;
  377.             case FONT:
  378.                 p_attr=(struct TextAttr *)p_g->p_data;
  379.                 SPrintF (vect,"%s=%s %ld %ld %ld",
  380.                     buffer_conv,
  381.                     p_attr->ta_Name,
  382.                     (ULONG)p_attr->ta_YSize,
  383.                     (ULONG)p_attr->ta_Style,
  384.                     (ULONG)p_attr->ta_Flags);
  385.                 printd("Font,value:%s ",vect);
  386.                 break;
  387.             default:
  388.                 break;
  389.     }
  390.     printd("\n");
  391.     return(vect);
  392. }
  393.  
  394. void SaveConfig(char *Name,struct tom_gadget *p_gadg)
  395. {
  396.     int    i,num,mem,mem2;
  397.     struct DiskObject *DiskObject;
  398.     ULONG Index;
  399.     char **NewToolTypes,**NextEntry,**OldToolTypes;
  400.  
  401.     printd("Save config:%s\n",Name);
  402.  
  403.     /* GetDiskObjectNew() is a 2.0 function    */
  404. #ifndef    WB_13
  405.     if ((DiskObject=GetDiskObjectNew(Name))!=NULL){
  406. #endif
  407. #ifdef    WB_13
  408.     if ((DiskObject=GetDiskObject(Name))!=NULL){
  409. #endif
  410.         Index=0L;
  411.         OldToolTypes=DiskObject->do_ToolTypes;
  412.         while (OldToolTypes[Index]) Index++;
  413.         num=0;
  414.         while(p_gadg[num].type_gadg!=END_LISTE){
  415.                 num++;
  416.         }
  417.         Index+=num+1;
  418.         printd("index=%d\n",Index);
  419.  
  420.         mem2=Index*4L+num*SIZE_VECT;
  421.         if ((NewToolTypes=(char **)AllocMem(mem2,
  422.                                      MEMF_PUBLIC|MEMF_CLEAR))==NULL){
  423.             FreeDiskObject (DiskObject);
  424.             return;
  425.         }
  426.         NextEntry=NewToolTypes;
  427.  
  428.         i=0;
  429.         while(p_gadg[i].type_gadg!=END_LISTE){
  430.                 if(i==0){
  431.                     *NextEntry++=add_gadg(&p_gadg[i],(char *)&NewToolTypes[Index]);
  432.                 }else{
  433.                     *NextEntry++=add_gadg(&p_gadg[i],NewToolTypes[i-1]+SIZE_VECT);
  434.                 }
  435.                 i++;
  436.         }
  437.  
  438.         Index=0L;
  439.         while (OldToolTypes[Index]){
  440.             char *Ptr,*Asgn;
  441.  
  442.             mem=strlen(OldToolTypes[Index])+1L;
  443.             if (Ptr=(char *)AllocMem(mem,0L)){
  444.                 if (Asgn=strchr(strcpy(Ptr,OldToolTypes[Index]),'=')){
  445.                     *Asgn='\0';
  446.                 }
  447.                 if (FindToolType(NewToolTypes,Ptr)==NULL){
  448.                         *NextEntry++=OldToolTypes[Index];
  449.                 }
  450.                 FreeMem ((APTR)Ptr,mem);
  451.             }
  452.             Index++;
  453. #ifndef WB_13
  454.         }
  455. #endif
  456.  
  457.         DiskObject->do_ToolTypes=NewToolTypes;
  458.         if (!PutDiskObject(Name,DiskObject)){
  459. /*
  460.              DisplayBeep (BlankerWindow->WScreen);
  461. */
  462.         }
  463.         DiskObject->do_ToolTypes=OldToolTypes;
  464. #ifdef WB_13
  465.         }
  466. #endif
  467.  
  468.         FreeMem ((APTR)NewToolTypes,mem2);
  469.         FreeDiskObject (DiskObject);
  470.     }
  471. }
  472.