home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 2 / DATAFILE_PDCD2.iso / utilities3 / discindex / DiscIndex / Source / C / Main < prev    next >
Encoding:
Text File  |  1994-08-04  |  9.9 KB  |  414 lines
  1. /* DiscIndex 1.00
  2.  * Main code - Main.c
  3.  * By Neil A Carson 1994 A.D.
  4.  */
  5.  
  6. #include <stdlib.h>
  7. #include <string.h>
  8.  
  9. #
  10. #include "baricon.h"
  11. #include "coords.h"
  12. #include "dbox.h"
  13. #include "discindex.h"
  14. #include "event.h"
  15. #include "flex.h"
  16. #include "heap.h"
  17. #include "kernel.h"
  18. #include "myswis.h"
  19. #include "res.h"
  20. #include "resspr.h"
  21. #include "template.h"
  22. #include "visdelay.h"
  23. #include "werr.h"
  24. #include "wimp.h"
  25. #include "wimpt.h"
  26. #include "win.h"
  27. #include "xferrecv.h"
  28. #include "xfersend.h"
  29. #
  30.  
  31. menu icon_menu;
  32. menu win_menu;
  33. dbox find_dbox, matches_dbox, scan_dbox, info_dbox, save_dbox;
  34. BOOL find_open = 0, matches_open = 0, scan_open = 0, info_open = 0;
  35. search_win_type search_win_info;
  36. match_win_type match_win_info;
  37. scan_win_type scan_win_info;
  38. char std_save_name[256]; /* For quick save */
  39. char s_filename[256]; /* For saveas handler */
  40.  
  41. int current_line = 0, current_disc = 0, current_i = -1;
  42.  
  43. void bar_click_handler(wimp_i);
  44. void icon_menu_handler(void *handle, char *hit);
  45. void win_menu_handler(void *handle, char *hit);
  46. void info_event_handler(dbox d, void *handle);
  47. BOOL save_handler(wimp_eventstr *, void *);
  48.  
  49. extern void fill_in_discinfo(BOOL scroll, dbox, int, int, int);
  50. extern void mem_man_init(void);
  51. extern void do_scan(disc_type *);
  52. extern void search(void);
  53.  
  54. extern BOOL save_records(char *, void *);
  55. extern BOOL load_records(char *, void *);
  56.  
  57. int main(int argc, char *argv[])
  58. {
  59.     wimpt_init("Disc Index");
  60.     visdelay_init();
  61.     visdelay_begin();
  62.     flex_init();
  63.     heap_init(TRUE);
  64.     mem_man_init();
  65.     res_init("DiscIndex");
  66.     resspr_init();
  67.     template_init();
  68.     dbox_init();
  69.     baricon("!DiscIndex", (int) resspr_area(), bar_click_handler);
  70.     if ((icon_menu = menu_new("Disc Index", ">Info, Help, >Save, Clear all, Quit")) == 0)
  71.         werr(1, "Unable to initialise menu (1)");
  72.     if ((win_menu = menu_new("Disc Index", ">Info|Go to start,Go to end,>Go to disc|Search...|>Save")) == 0)
  73.         werr(1, "Unable to initialise menu (2)");
  74.     event_attachmenu(win_ICONBAR, icon_menu, icon_menu_handler, 0);
  75.     memset(&search_win_info, sizeof(search_win_type), 0);
  76.     memset(&scan_win_info, sizeof(scan_win_type), 0);
  77.     memset(&match_win_info, sizeof(match_win_type), 0);
  78.     visdelay_end();
  79.  
  80.     if (argc > 1) load_records(argv[1], 0);
  81.  
  82.     for (;;)
  83.     {
  84.         char *filename;
  85.         event_process();
  86.         if (xferrecv_checkinsert(&filename) == 0x345)
  87.             load_records(filename, 0);
  88.     }
  89. }
  90.  
  91. BOOL save_handler(wimp_eventstr *e, void *handle)
  92. {
  93.     wimp_mousestr m;
  94.  
  95.     handle = handle;
  96.  
  97.     if (e->e != wimp_EUSERDRAG) return FALSE; /* Only want a User Drag end */
  98.  
  99.     wimpt_noerr(wimp_get_point_info(&m));
  100.     dbox_dispose(&save_dbox);
  101.     if (m.w != dbox_syshandle(save_dbox))
  102.         xfersend(0x345, s_filename, 300, save_records, 0, 0, e, 0);
  103.     /* Remove itself! */
  104.     win_remove_unknown_event_processor(save_handler, (void *) 116140);
  105.     return TRUE;
  106. }
  107.  
  108. void set_current_disc(int no)
  109. {
  110.     if ((no < 0) || (no >= records.no)) return;
  111.     current_disc = no;
  112.     current_line = 0;
  113.     current_i = -1;
  114.     if (info_open)
  115.         fill_in_discinfo(0, info_dbox, current_disc, current_i, current_line);
  116. }
  117.  
  118. void do_save(void)
  119. {
  120.     save_dbox = dbox_new("xfer_send");
  121.     dbox_setfield(save_dbox, 1, "Records");
  122.     dbox_show(save_dbox);
  123.     switch(dbox_fillin(save_dbox))
  124.     {
  125.         case 0:
  126.         dbox_getfield(save_dbox, 1, s_filename,192);
  127.         dbox_dispose(&save_dbox);
  128.         if (strchr(s_filename, '.') == 0)
  129.             werr(0, "To save, drag the icon to a filer window!");
  130.         else save_records(s_filename, 0);
  131.         break;
  132.  
  133.         case 2:
  134.         {
  135.             wimp_wstate state;
  136.             coords_cvtstr c;
  137.             wimp_icon icon;
  138.             wimp_box ibox;
  139.             _kernel_swi_regs r;
  140.  
  141.             dbox_getfield(save_dbox, 1, s_filename, 64);
  142.             wimpt_noerr(wimp_get_wind_state(dbox_syshandle(save_dbox), &state));
  143.             wimpt_noerr(wimp_get_icon_info(dbox_syshandle(save_dbox), 2, &icon));
  144.             c.box = state.o.box;
  145.             c.scx = state.o.x;
  146.             c.scy = state.o.y;
  147.             ibox = icon.box;
  148.             coords_box_toscreen(&ibox, &c);
  149.             c.box = state.o.box;
  150.             c.scx = state.o.x;
  151.             c.scy = state.o.y;
  152.             r.r[0] = 0x85;
  153.             r.r[1] = 1;
  154.             r.r[2] = (int) "file_345";
  155.             r.r[3] = (int) &ibox;
  156.             r.r[4] = 0;
  157.             _kernel_swi(DragASprite_Start, &r, &r);
  158.             win_add_unknown_event_processor(save_handler, (void *) 116140);
  159.         }
  160.         break;
  161.  
  162.         default: break;
  163.     }
  164. }
  165.  
  166. void bar_click_handler(wimp_i i)
  167. {
  168.     i = i;
  169.  
  170.     if (!info_open)
  171.     {
  172.         info_dbox = dbox_new("DiscInfo");
  173.         dbox_showstatic(info_dbox);
  174.         dbox_eventhandler(info_dbox, info_event_handler, 0);
  175.         event_attachmenu(dbox_syshandle(info_dbox),win_menu,win_menu_handler,0);
  176.         fill_in_discinfo(0, info_dbox, current_disc, -1, current_line);
  177.         info_open = 1;
  178.     }
  179. }
  180.  
  181. void icon_menu_handler(void *handle, char *hit)
  182. {
  183.     handle = handle;
  184.  
  185.     switch(hit[0])
  186.     {
  187.         case 1:
  188.         {
  189.             dbox d = dbox_new("Info");
  190.             dbox_showstatic(d);
  191.             dbox_fillin(d);
  192.             dbox_dispose(&d);
  193.         }
  194.         break;
  195.  
  196.         case 2:
  197.         system("Filer_OpenDir <DiscIndex$Dir>.Help");
  198.         break;
  199.  
  200.         case 3:
  201.         do_save();
  202.         break;
  203.  
  204.         case 4:
  205.         {
  206.             os_error e;
  207.             _kernel_swi_regs r;
  208.  
  209.             e.errnum = 0;
  210.             strcpy(e.errmess, "Are you sure you want to delete all (no undo!)");
  211.             r.r[0] = (int) &e;
  212.             r.r[1] = 3;
  213.             r.r[2] = (int) "Disc Index";
  214.             _kernel_swi(0x400DF, &r, &r);
  215.  
  216.             if (r.r[1] == 1) mem_free();
  217.         }
  218.         break;
  219.  
  220.         case 5:
  221.         exit(0);
  222.         break;
  223.  
  224.         default: break;
  225.     }
  226. }
  227.  
  228. int locate(void)
  229. {
  230.     int f;
  231.  
  232.     f = current_i - 15;
  233.     f += (current_line << 1);
  234.  
  235.     return f;
  236. }
  237.  
  238. void info_event_handler(dbox d, void *handle)
  239. {
  240.     dbox_field f;
  241.  
  242.     handle = handle;
  243.  
  244.     f = dbox_get(d);
  245.  
  246.     if ((f >= 15) && (f <= 30))
  247.     {
  248.         current_i = f;
  249.         fill_in_discinfo(0, info_dbox, current_disc, current_i, current_line);
  250.         return;
  251.     }
  252.  
  253.     switch(f)
  254.     {
  255.         case dbox_CLOSE:
  256.         dbox_dispose(&d);
  257.         dbox_eventhandler(d, 0, 0);
  258.         info_open = 0;
  259.         break;
  260.  
  261.         case 1:
  262.         dbox_getfield(d, 11, disc_locate(current_disc)->disc_desc, 32);
  263.         break;
  264.  
  265.         case 6:
  266.         if (current_disc == 0)
  267.         {
  268.             printf("%c", 7); /* Beep an error! */
  269.             return;
  270.         }
  271.         current_disc --;
  272.         current_line = 0;
  273.         current_i = -1;
  274.         fill_in_discinfo(0, info_dbox, current_disc, current_i, current_line);
  275.         break;
  276.  
  277.         case 7:
  278.         if (current_disc >= (records.no - 1))
  279.         {
  280.             printf("%c", 7); /* Beep an error! */
  281.             return;
  282.         }
  283.         current_disc ++;
  284.         current_line = 0;
  285.         current_i = -1;
  286.         fill_in_discinfo(0, info_dbox, current_disc, current_i, current_line);
  287.         break;
  288.  
  289.         case 31:
  290.         if (current_line == 0)
  291.         {
  292.             printf("%c", 7);
  293.             return;
  294.         }
  295.         current_line --;
  296.         current_i = -1;
  297.         fill_in_discinfo(1, info_dbox, current_disc, current_i, current_line);
  298.         break;
  299.  
  300.         case 32:
  301.         if (current_line > (disc_locate(current_disc)->no >> 1))
  302.         {
  303.             printf("%c", 7);
  304.             return;
  305.         }
  306.         current_line ++;
  307.         current_i = -1;
  308.         fill_in_discinfo(1, info_dbox, current_disc, current_i, current_line);
  309.         break;
  310.  
  311.         case 49:
  312.         dbox_getfield(d, 48,
  313.                       disc_locate(current_disc)->files[locate()].desc, 32);
  314.         break;
  315.  
  316.         case 35:
  317.         do_scan(disc_locate(current_disc));
  318.         current_i = -1;
  319.         current_line = 0;
  320.         fill_in_discinfo(0, info_dbox, current_disc, current_i, current_line);
  321.         break;
  322.  
  323.         case 36:
  324.         if (disc_create() == 0) break;
  325.         current_disc = records.no - 1;
  326.         current_line = 0;
  327.         current_i = -1;
  328.         do_scan(disc_locate(current_disc));
  329.         fill_in_discinfo(0, info_dbox, current_disc, current_i, current_line);
  330.         break;
  331.  
  332.         case 37:
  333.         if (disc_create() == 0) break;
  334.         current_disc = records.no - 1;
  335.         current_line = 0;
  336.         current_i = -1;
  337.         fill_in_discinfo(0, info_dbox, current_disc, current_i, current_line);
  338.         break;
  339.  
  340.         case 38:
  341.         if (current_disc == 0)
  342.         {
  343.             werr(0, "Can't delete disc 0!");
  344.             break;
  345.         }
  346.         if (disc_destroy(current_disc) != 1) break;
  347.         current_disc --;
  348.         current_line = 0;
  349.         current_i = -1;
  350.         fill_in_discinfo(0, info_dbox, current_disc, current_i, current_line);
  351.         break;
  352.  
  353.         case 39:
  354.         save_records(std_save_name, 0);
  355.         break;
  356.  
  357.         case 52:
  358.         if (disc_insert(current_disc))
  359.         {
  360.             current_line = 0;
  361.             current_i = -1;
  362.             fill_in_discinfo(0, info_dbox, current_disc, current_i,
  363.                              current_line);
  364.         }
  365.         break;
  366.  
  367.         default: break;
  368.     }
  369. }
  370.  
  371. void win_menu_handler(void *handle, char *hit)
  372. {
  373.     handle = handle;
  374.  
  375.     switch(hit[0])
  376.     {
  377.         case 1:
  378.         {
  379.             dbox d = dbox_new("Info");
  380.             dbox_show(d);
  381.             dbox_fillin(d);
  382.             dbox_dispose(&d);
  383.         }
  384.         break;
  385.  
  386.         case 2:
  387.         set_current_disc(0);
  388.         break;
  389.  
  390.         case 3:
  391.         set_current_disc(records.no - 1);
  392.         break;
  393.  
  394.         case 4:
  395.         {
  396.             dbox d = dbox_new("Goto");
  397.             dbox_setnumeric(d, 0, current_disc + 1);
  398.             dbox_show(d);
  399.             if (dbox_fillin(d) == 2)
  400.                 set_current_disc(dbox_getnumeric(d, 0) - 1);
  401.             dbox_dispose(&d);
  402.         }
  403.         break;
  404.  
  405.         case 5:
  406.         search();
  407.         break;
  408.  
  409.         case 6:
  410.         do_save();
  411.         break;
  412.     }
  413. }
  414.