home *** CD-ROM | disk | FTP | other *** search
/ ARM Club 1 / ARM_CLUB_CD.iso / contents / apps / paint / a / hackspr / !HackSpr / c / main
Encoding:
Text File  |  1992-06-09  |  11.0 KB  |  355 lines
  1. /* c.main
  2.  
  3.    Search out sprite files and correct their palettes to ensure that
  4.    the lower nibble of the RGB components is the same as the upper nibble
  5. */
  6.  
  7. #define INFO_VERSION_FIELD      3
  8. #define MENU_INFO               1
  9. #define MENU_QUIT               2
  10.  
  11. #include <stdlib.h>
  12. #include <string.h>
  13.  
  14. #include "h.bbc"
  15. #include "h.dbox"
  16. #include "h.drawftypes"
  17. #include "h.event"
  18. #include "h.menu"
  19. #include "h.msgs"
  20. #include "h.res"
  21. #include "h.template"
  22. #include "h.visdelay"
  23. #include "h.werr"
  24. #include "h.wimp"
  25. #include "h.wimpt"
  26. #include "h.win"
  27.  
  28.   menu M_main;
  29. wimp_w W_main;
  30.  
  31. BOOL main_hack_sprite_palette(sprite_header *sprite)
  32. {
  33.         int ncols = bbc_modevar(sprite->mode, bbc_NColour), i, part1, part2, returnflag = FALSE;
  34.         int *palette = (int *)((int)sprite + 11*4);
  35.  
  36.         /* if there isn't a palette to process, or it isn't a 16 colour palette, quit now */
  37.         if (sprite->image == 11*4 || ncols != 15)
  38.                 return FALSE;
  39.         for (i = 0; i < 32; i++)
  40.         {
  41.                 part1 = (palette[i] & 0xF0F0F000) >> 4;
  42.                 part2 = (palette[i] & 0x0F0F0F00);
  43.                 if (part1 != part2)
  44.                 {
  45.                         palette[i] = (palette[i] & 0xFF) + part1 + (part1 << 4);
  46.                         if (!returnflag)
  47.                         {
  48.                                 returnflag = TRUE;
  49.                                 printf("Adjusting palette of '%s'\n",sprite->name);
  50.                         }
  51.                 }
  52.         }
  53.         return returnflag;
  54. }
  55.  
  56. BOOL main_translate_sprite(char *name)
  57. {
  58.         os_filestr filestr;
  59.         sprite_area *sprites;
  60.         sprite_header *sprite;
  61.         int i, fixed = FALSE;
  62.  
  63.         filestr.action = 17;
  64.         filestr.name = name;
  65.         if (wimpt_complain(os_file(&filestr)))
  66.                 return FALSE;
  67.         sprites = (sprite_area *)malloc(filestr.start+4);
  68.         if (!sprites)
  69.         {
  70.                 printf("%s\n%s\n",msgs_lookup("OK2"),msgs_lookup("OK0"));
  71.                 return FALSE;
  72.         }
  73.         sprites->size = filestr.start+4;
  74.         sprites->sproff = 16;
  75.         if (wimpt_complain(sprite_area_reinit(sprites)) ||
  76.             wimpt_complain(sprite_area_load(sprites,name)))
  77.         {
  78.                 free(sprites);
  79.                 return FALSE;
  80.         }
  81.         i = sprites->number;
  82.         sprite = (sprite_header *)((int)sprites + sprites->sproff);
  83.         printf("Checking '%s'\n",name);
  84.         while (i)
  85.         {
  86.                 if (main_hack_sprite_palette(sprite))
  87.                         fixed = TRUE;
  88.                 sprite = (sprite_header *)((int)sprite + sprite->next);
  89.                 i--;
  90.         }
  91.         if (fixed && wimpt_complain(sprite_area_save(sprites,name)))
  92.         {
  93.                 free(sprites);
  94.                 return FALSE;
  95.         }
  96.         free(sprites);
  97.         return TRUE;
  98. }
  99.  
  100. BOOL main_translate_draw(char *name)
  101. {
  102.         os_filestr filestr;
  103.         sprite_header *sprite;
  104.         char *draw, *current, *draw_end;
  105.         int fixed = FALSE, output_details = FALSE;
  106.  
  107.         filestr.action = 17;
  108.         filestr.name = name;
  109.         if (wimpt_complain(os_file(&filestr)))
  110.                 return FALSE;
  111.         draw = (char *)malloc(filestr.start);
  112.         draw_end = draw + filestr.start;
  113.         current = draw + sizeof(draw_fileheader);
  114.         if (!draw)
  115.         {
  116.                 printf("%s\n%s\n",msgs_lookup("OK3"),msgs_lookup("OK0"));
  117.                 return FALSE;
  118.         }
  119.         filestr.action = 16;
  120.         filestr.name = name;
  121.         filestr.loadaddr = (int)draw;
  122.         filestr.execaddr = 0;
  123.         if (wimpt_complain(os_file(&filestr)))
  124.         {
  125.                 free(draw);
  126.                 return FALSE;
  127.         }
  128.         while (current < draw_end)
  129.         {
  130.                 draw_objhdr *objhdr = (draw_objhdr *)current;
  131.  
  132.                 if (objhdr->tag == 5)
  133.                 {
  134.                         if (!output_details)
  135.                         {
  136.                                 printf("Checking '%s'\n",name);
  137.                                 output_details = TRUE;
  138.                         }
  139.  
  140.                         sprite = &((draw_spristr *)objhdr)->sprite;
  141.                         if (main_hack_sprite_palette(sprite))
  142.                                 fixed = TRUE;
  143.                 }
  144.                 current += objhdr->size;
  145.         }
  146.         if (fixed)
  147.         {
  148.                 filestr.action = 0;
  149.                 filestr.start = (int)draw;
  150.                 filestr.end = (int)draw_end;
  151.                 if (wimpt_complain(os_file(&filestr)))
  152.                 {
  153.                         free(draw);
  154.                         return FALSE;
  155.                 }
  156.         }
  157.         free(draw);
  158.         return TRUE;
  159. }
  160.  
  161. typedef struct
  162. {
  163.         int load_address;
  164.         int execution_address;
  165.         int length;
  166.         int file_attributes;
  167.         int object_type;
  168.         char name[256];
  169. } gbpb_10_str;
  170.  
  171. BOOL main_translate_dirs(char *name)
  172. {
  173.         char entries[256];
  174.         os_gbpbstr gbpbstr;
  175.  
  176.         printf("Checking '%s'\n",name);
  177.         gbpbstr.action = 10;
  178.         gbpbstr.file_handle = (int)name;
  179.         gbpbstr.data_addr = entries;
  180.         gbpbstr.seq_point = 0;
  181.         gbpbstr.buf_len = 256;
  182.         gbpbstr.wild_fld = "*";
  183.         do {
  184.                 gbpbstr.number = 1;
  185.                 if (wimpt_complain(os_gbpb(&gbpbstr)))
  186.                         return FALSE;
  187.                 if (gbpbstr.number == 1)
  188.                 {
  189.                         gbpb_10_str *gbpb_10 = (gbpb_10_str *)entries;
  190.                         char *new_name = (char *)malloc(strlen(name)+strlen(gbpb_10->name)+2);
  191.                         BOOL result=TRUE;
  192.  
  193.                         strcpy(new_name,name);
  194.                         strcat(new_name,".");
  195.                         strcat(new_name,gbpb_10->name);
  196.  
  197.                         if (gbpb_10->object_type == 2)
  198.                         {
  199.  
  200.                                 result = main_translate_dirs(new_name);
  201.                         }
  202.                         else if ((gbpb_10->load_address & 0xFFF00000) == 0xFFF00000)
  203.                         {
  204.                                 switch ((gbpb_10->load_address & 0x000FFF00)>>8)
  205.                                 {
  206.                                         case 0xFF9: /* Sprite */
  207.                                                 result = main_translate_sprite(new_name);
  208.                                                 break;
  209.                                         case 0xAFF: /* Draw file */
  210.                                                 result = main_translate_draw(new_name);
  211.                                                 break;
  212.                                 }
  213.                         }
  214.  
  215.                         free(new_name);
  216.                         if (!result)
  217.                                 return FALSE;
  218.                 }
  219.         } while (gbpbstr.seq_point != -1);
  220.  
  221.         return TRUE;
  222. }
  223.  
  224. void main_open_command(void)
  225. {
  226.         wimp_commandwind windinfo;
  227.  
  228.         windinfo.tag = wimp_command_TITLE;
  229.         windinfo.title = "HackSprites status";
  230.         wimp_commandwindow(windinfo);
  231. }
  232.  
  233. void main_close_command(BOOL prompt)
  234. {
  235.         wimp_commandwind windinfo;
  236.  
  237.         if (prompt)
  238.                 windinfo.tag = wimp_command_CLOSE_PROMPT;
  239.         else
  240.                 windinfo.tag = wimp_command_CLOSE_NOPROMPT;
  241.         wimp_commandwindow(windinfo);
  242. }
  243.  
  244. void main_do_info(void)
  245. {
  246.         dbox d = dbox_new("info");
  247.  
  248.         if (d)
  249.         {
  250.                 dbox_setfield(d, INFO_VERSION_FIELD, msgs_lookup("VSN"));
  251.                 dbox_show(d);
  252.                 dbox_fillin(d);
  253.                 dbox_dispose(&d);
  254.         }
  255. }
  256.  
  257. void main_menuproc(void *handle, char *hit)
  258. {
  259.         switch (hit[0])
  260.         {
  261.                 case MENU_INFO:
  262.                         if (hit[1]) main_do_info();
  263.                         break;
  264.                 case MENU_QUIT:
  265.                         exit(0);
  266.         }
  267. }
  268.  
  269. void main_event_handler(wimp_eventstr *e, void *handle)
  270. {
  271.         switch (e->e)
  272.         {
  273.                 case wimp_EOPEN:
  274.                         wimp_open_wind(&e->data.o);
  275.                         break;
  276.                 case wimp_ECLOSE:
  277.                         win_activedec();
  278.                         break;
  279.                 case wimp_ESEND:
  280.                 case wimp_ESENDWANTACK:
  281.                         if (e->data.msg.hdr.action == wimp_MDATALOAD)
  282.                         {
  283.                                 BOOL prompt_wanted = TRUE;
  284.  
  285.                                 if (e->data.msg.data.dataload.type == 0xFF9 ||
  286.                                     e->data.msg.data.dataload.type == 0xAFF ||
  287.                                     e->data.msg.data.dataload.type == 0x1000 ||
  288.                                     e->data.msg.data.dataload.type == 0x2000)
  289.                                         main_open_command();
  290.  
  291.                                 switch (e->data.msg.data.dataload.type)
  292.                                 {
  293.                                         case 0xFF9: /* Sprite */
  294.                                                 prompt_wanted = main_translate_sprite(e->data.msg.data.dataload.name);
  295.                                                 break;
  296.                                         case 0xAFF: /* Draw file */
  297.                                                 prompt_wanted = main_translate_draw(e->data.msg.data.dataload.name);
  298.                                                 break;
  299.                                         case 0x1000:
  300.                                         case 0x2000:
  301.                                                 prompt_wanted = main_translate_dirs(e->data.msg.data.dataload.name);
  302.                                                 break;
  303.                                         default:
  304.                                                 werr(FALSE,msgs_lookup("OK1"));
  305.                                                 break;
  306.                                 }
  307.  
  308.                                 if (e->data.msg.data.dataload.type == 0xFF9 ||
  309.                                     e->data.msg.data.dataload.type == 0xAFF ||
  310.                                     e->data.msg.data.dataload.type == 0x1000 ||
  311.                                     e->data.msg.data.dataload.type == 0x2000)
  312.                                         main_close_command(prompt_wanted);
  313.                         }
  314.                         break;
  315.         }
  316. }
  317.  
  318. int main_initialise(void)
  319. {
  320.         wimp_wstate res;
  321.  
  322.         visdelay_begin();
  323.         res_init("HackSpr");
  324.         msgs_init();
  325.         wimpt_init(msgs_lookup("ID"));
  326.         template_init();
  327.         if (wimp_create_wind(template_syshandle("main"),&W_main))
  328.                 return FALSE;
  329.         win_register_event_handler(W_main,main_event_handler,0);
  330.         if ((M_main = menu_new(msgs_lookup("ME1"),msgs_lookup("ME2"))) == NULL)
  331.                 return FALSE;
  332.         if (!event_attachmenu(W_main,M_main,main_menuproc,0))
  333.                 return FALSE;
  334.  
  335.         visdelay_end();
  336.  
  337.         win_activeinc();
  338.         wimp_get_wind_state(W_main, &res);
  339.         wimp_open_wind(&res.o);
  340.  
  341.         return TRUE;
  342. }
  343.  
  344. int main(void)
  345. {
  346.         if (!main_initialise())
  347.         {
  348.                 werr(FALSE, "Failed to initialise!");
  349.                 exit(0);
  350.         }
  351.  
  352.         while(TRUE)
  353.                 event_process();
  354. }
  355.