home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Exec 5 / CD_Magazyn_EXEC_nr_5.iso / Programy / Programowanie / FetchRefs2.1.lha / FetchRefs2.1 / Source / GenerateIndex / GUI.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-01-28  |  30.9 KB  |  1,218 lines
  1. #include "GenerateIndex.h"
  2.  
  3. extern struct Library * GTLayoutBase, * LocaleBase;
  4. extern APTR catalog;
  5. struct rtFileRequester *DataFileReq, *AddFileReq, *PrefsFileReq;
  6. struct LayoutHandle * MainPrj, * ScanStatPrj, * OptionsPrj, * RefPrj;
  7.  
  8. BOOL GoOn = TRUE, FileChanged;
  9.  
  10. enum { LISTE_REFERENCES=1, NBRE_REFERENCES, SCAN_NEWREF, DELETE_FILE, OPTIONS, RESCAN_REF,
  11.     RESCAN_ALL, SAVE_REFS, LOAD_REFS, CLEAR, INFOS, QUIT,
  12.     AUTODOCS, C_INCLUDES, E_INCLUDES, ASM_INCLUDES, DEFINES, STRUCT_UNIONS,
  13.     TYPEDEFS, CONSTANTES, OBJECTS, PROCEDURES, EQU_BITDEF, STRUCTURES, MACROS,
  14.     SCAN_DRAWERS_RECURS, TREAT_UNRECOGNIZED_FILES, KEEP_FILES, LOAD_OPT, SAVE_OPT, SAVEAS_OPT,
  15.     USE_OPT, LASTSAVED, CANCEL_OPT, INPUT_REFERENCES,
  16.     REF_FILE, OFFSET, LINE, SIZE, DELETE_REF
  17. };
  18.  
  19. #define SPREAD 1
  20. #define SAME_SIZE 2
  21. #define FRAME 4
  22.  
  23. /* Localisation tables */
  24. enum { NULL_STRING=0, REFERENCES_LOC, SCANNEW_LOC, DELETE_LOC, OPTIONS_LOC, RESCAN_LOC,
  25.     RESCAN_ALL_LOC, SAVE_REFS_LOC, LOAD_REFS_LOC, CLEAR_REFS_LOC, ABOUT_LOC, QUIT_LOC,
  26.     /* References window */
  27.     FILE_LOC, OFFSET_LOC, SIZE_LOC, LINE_LOC,
  28.     /* Prefs window */
  29.     GEN_OPT_LOC, AUTODOCS_LOC, C_INCLUDES_LOC, DEFINES_LOC, STRUCTUNIONS_LOC, TYPDEDEF_LOC,
  30.     E_INCLUDES_LOC, CONST_LOC, OBJECT_LOC, PROC_LOC,
  31.     ASM_INCLUDES_LOC, EQUBITDEF_LOC, STRUCTURE_LOC, MACRO_LOC,
  32.     SCAN_RECURS_LOC, UNRECOGNIZED_LOC, KEEP_FILES_LOC,
  33.     LOADPREFS_LOC, LASTSAVED_LOC, CANCEL_LOC, SAVEAS_LOC, USEREFS_LOC,
  34.     /* Stop scanning window */
  35.     SCANNING_LOC, STOP_SCANNING_LOC,
  36.     /* Other messages */
  37.     SELECT_INDEXFILES_LOC, LOOSE_CHANGES_LOC, OK_CANCEL_LOC, NOEMPTYLIST_LOC,
  38.     REPLACE_APPEND_LOC, CLEAR_LIST_LOC,
  39. };
  40.  
  41. char * strings[] = {    "", "References", "Scan...", "Delete", "Options...", "Rescan",
  42.     "Rescan all", "Save", "Load", "Clear", "About", "Quit",
  43.     /* References window */
  44.     "File", "Offset", "Size", "Line",
  45.     /* Prefs window */
  46.     "GenerateIndex Options", "AutoDocs", "C includes", "#define", "struct/union", "typedef",
  47.     "E includes", "CONST", "Object", "PROC",
  48.     "ASM includes", "EQU/BITDEF", "STRUCTURE", "MACRO",
  49.     "Scan drawers recursively", "Treat unrecognized files as Autodocs",
  50.     "Keep files without references",
  51.     "Load...", "Last saved", "Cancel", "Save as...", "Use",
  52.     /* Stop scanning window */
  53.     "Scanning...", "Stop scanning",
  54.     /* Other messages */
  55.     "Select files to index...", "There are changes!\nReally load a new file?",
  56.     "_Okay|_Cancel", "Current list is not empty!", "_Replace|_Append|_Cancel",
  57.     "There are changes!\nReally clear the entire list?"
  58. };
  59.  
  60. char * __regargs GetString (long indice)
  61. {   STRPTR def = strings[indice];
  62.     return (catalog ? GetCatalogStr (catalog, indice, def) : def);
  63. }
  64.  
  65. __saveds __asm char * LocaleHookFunc (register __a0 struct Hook * UnusedHook, register __a2 APTR Unused, register __a1 long ID)
  66. {
  67.     return GetString(ID);
  68. }
  69.  
  70. struct Hook LocaleHook = { 0, 0, (HOOKFUNC) LocaleHookFunc, 0, 0 };
  71.  
  72. void CloseProject (struct TR_Project * p)
  73. {
  74. }
  75.  
  76. static void __regargs New_Horizontal_group (struct LayoutHandle * h, long tag)
  77. {   long i = 1;
  78.     struct TagItem tags[5];
  79.  
  80.     tags[0].ti_Tag = LA_Type;
  81.     tags[0].ti_Data = HORIZONTAL_KIND;
  82.     if (tag & SPREAD)
  83.     {    tags[i].ti_Tag = LAGR_Spread;    tags[i].ti_Data = TRUE; i++;    }
  84.     if (tag & SAME_SIZE)
  85.     {    tags[i].ti_Tag = LAGR_SameSize; tags[i].ti_Data = TRUE; i++;    }
  86.     if (tag & FRAME)
  87.     {    tags[i].ti_Tag = LAGR_Frame;    tags[i].ti_Data = TRUE; i++;    }
  88.     tags[i].ti_Tag = TAG_DONE;
  89.     LT_NewA (h, tags);
  90. }
  91.  
  92. static void __regargs New_Button (struct LayoutHandle * h, long id, long locale_ID)
  93. {
  94.     LT_New (h,
  95.     LA_Type,    BUTTON_KIND,
  96.     LA_ID,        id,
  97.     LA_LabelID, locale_ID,
  98.     TAG_DONE);
  99. }
  100.  
  101. static void __regargs New_CheckBox (struct LayoutHandle * handle, long id, long label)
  102. {
  103.     LT_New (handle,
  104.     LA_Type,    CHECKBOX_KIND,
  105.     LA_ID,        id,
  106.     LA_LabelID,    label,
  107.     LA_LabelPlace,    PLACE_Right,
  108.     TAG_DONE);
  109. }
  110.  
  111. static struct LayoutHandle * CreateMainWindow (void)
  112. {
  113.     struct LayoutHandle * h = LT_CreateHandleTags (0, LAHN_LocaleHook, &LocaleHook, TAG_DONE);
  114.     if (h)
  115.     {
  116.     LT_New (h, LA_Type, VERTICAL_KIND, TAG_DONE);
  117.     {   LT_New (h, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, TAG_DONE);
  118.         {
  119.         LT_New (h,
  120.             LA_Type,        LISTVIEW_KIND,
  121.             LA_Chars,        31,
  122.             LALV_Lines,     10,
  123.             LALV_ResizeY,   TRUE,
  124.             LALV_ResizeX,   TRUE,
  125.             LALV_CursorKey, TRUE,
  126.             LALV_Link,        NIL_LINK,
  127.             LA_ID,        LISTE_REFERENCES,
  128.         TAG_DONE);
  129.         New_Horizontal_group (h, 0);
  130.         {
  131.             LT_New (h,
  132.             LA_Type,    TEXT_KIND,
  133.             LATX_Picker, TRUE,
  134.             LA_Chars,   31-strlen(GetString(REFERENCES_LOC)),
  135.             LA_LabelID, REFERENCES_LOC,
  136.             GTTX_Border, TRUE,
  137.             LA_ID,        NBRE_REFERENCES,
  138.             TAG_DONE);
  139.             LT_EndGroup (h);
  140.         }
  141.         LT_EndGroup (h);
  142.         }
  143.         LT_New (h, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, TAG_DONE);
  144.         {
  145.         New_Horizontal_group (h, SPREAD | SAME_SIZE);
  146.         {   New_Button (h, SCAN_NEWREF, SCANNEW_LOC);
  147.             New_Button (h, DELETE_FILE, DELETE_LOC);
  148.             New_Button (h, OPTIONS, OPTIONS_LOC);
  149.             LT_EndGroup (h);
  150.         }
  151.         New_Horizontal_group (h, SAME_SIZE);
  152.         {   New_Button (h, RESCAN_REF, RESCAN_LOC);
  153.             New_Button (h, RESCAN_ALL, RESCAN_ALL_LOC);
  154.             LT_EndGroup (h);
  155.         }
  156.         LT_EndGroup (h);
  157.         }
  158.         LT_New (h, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, TAG_DONE);
  159.         {
  160.         New_Horizontal_group (h, SPREAD | SAME_SIZE);
  161.         {   New_Button (h, SAVE_REFS, SAVE_REFS_LOC);
  162.             New_Button (h, LOAD_REFS, LOAD_REFS_LOC);
  163.             New_Button (h, CLEAR, CLEAR_REFS_LOC);
  164.             New_Button (h, INFOS, ABOUT_LOC);
  165.             New_Button (h, QUIT, QUIT_LOC);
  166.             LT_EndGroup (h);
  167.         }
  168.         LT_EndGroup (h);
  169.         }
  170.         LT_EndGroup (h);
  171.     }
  172.     if (LT_Build (h,
  173.         LAWN_Title,     "GenerateIndex",
  174.         LAWN_IDCMP,     IDCMP_CLOSEWINDOW | LISTVIEWIDCMP | RAWKEY,
  175.         WA_DepthGadget, TRUE,
  176.         WA_RMBTrap,     TRUE,
  177.         WA_DragBar,     TRUE,
  178.         WA_Activate,    TRUE,
  179.         WA_CloseGadget, TRUE,
  180.     TAG_DONE))
  181.         return h;
  182.  
  183.     LT_DeleteHandle (h);
  184.     }
  185.     return 0;
  186. }
  187.  
  188. void About (void)
  189. {
  190.     rtEZRequestTags ("GenerateIndex " VERSION " " DATE "\n"
  191.              "Index file generator for FetchRefs\n"
  192.              "\n"
  193.              "By Roland Florac, FreeWare, 2000-2001\n\n"
  194.              "Original program by Anders Melchiorsen\n"
  195.              "1994-1996",
  196.              "Okay",
  197.              NULL, NULL,
  198.              RTEZ_Flags, EZREQF_CENTERTEXT,
  199.              TAG_END,     NULL
  200.             );
  201. }
  202.  
  203. /* OpenRefWindow() */
  204. void OpenReferencesWindow (void)
  205. {
  206.     struct LayoutHandle * h;
  207.  
  208.     if (! RefPrj)
  209.     {
  210.     /* We call UpdateMain() because it also updates the text gadget
  211.      * with the file name of the ref window. */
  212.     h = LT_CreateHandleTags (0, LAHN_LocaleHook, &LocaleHook, TAG_DONE);
  213.     if (h)
  214.     {   LT_New (h, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, TAG_DONE);
  215.         {
  216.         LT_New (h,
  217.             LA_Type,        LISTVIEW_KIND,
  218.             LA_Chars,        31,
  219.             LALV_Lines,     10,
  220.             LALV_ResizeY,   TRUE,
  221.             LALV_ResizeX,   TRUE,
  222.             LALV_CursorKey, TRUE,
  223.             LALV_Link,        NIL_LINK,
  224.             LA_ID,        INPUT_REFERENCES,
  225.         TAG_DONE);
  226.         New_Horizontal_group (h, SPREAD | SAME_SIZE | FRAME);
  227.         {
  228.             LT_New (h,
  229.             LA_Type,    TEXT_KIND,
  230.             LA_Chars,   31-strlen(GetString(FILE_LOC)),
  231.             LA_LabelID, FILE_LOC,
  232.             GTTX_Border, TRUE,
  233.             LA_ID,        REF_FILE,
  234.             TAG_DONE);
  235.             LT_EndGroup (h);
  236.         }
  237.         LT_New (h, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, TAG_DONE);
  238.         {
  239.             LT_New (h,
  240.             LA_Type,    TEXT_KIND,
  241.             LA_Chars,   12,
  242.             LA_LabelID, OFFSET_LOC,
  243.             GTTX_Border, TRUE,
  244.             LA_ID,        OFFSET,
  245.             TAG_DONE);
  246.             LT_New (h,
  247.             LA_Type,    TEXT_KIND,
  248.             LA_Chars,   12,
  249.             LA_LabelID, SIZE_LOC,
  250.             GTTX_Border, TRUE,
  251.             LA_ID,        SIZE,
  252.             TAG_DONE);
  253.             LT_New (h,
  254.             LA_Type,    TEXT_KIND,
  255.             LA_Chars,   12,
  256.             LA_LabelID, LINE_LOC,
  257.             GTTX_Border, TRUE,
  258.             LA_ID,        LINE,
  259.             TAG_DONE);
  260.             LT_EndGroup (h);
  261.         }
  262.         New_Button (h, DELETE_REF, DELETE_LOC);
  263.         }
  264.         LT_EndGroup (h);
  265.         if (LT_Build (h,
  266.         LAWN_Title,    GetString(REFERENCES_LOC),
  267.         LAWN_IDCMP,    IDCMP_CLOSEWINDOW | LISTVIEWIDCMP | RAWKEY,
  268.         WA_DepthGadget, TRUE,
  269.         WA_RMBTrap,    TRUE,
  270.         WA_DragBar,    TRUE,
  271.         WA_Activate,    TRUE,
  272.         WA_CloseGadget, TRUE,
  273.         TAG_DONE))
  274.         {
  275.         RefPrj = h;
  276.         UpdateMain();
  277.         }
  278.         else
  279.         LT_DeleteHandle (h);
  280.     }
  281.     }
  282.     else
  283.     {
  284.     struct Window * win;
  285.  
  286.     /* Bring the ref window to the front */
  287.     if (win = RefPrj->Window)
  288.     {
  289.         WindowToFront (win);
  290.         ActivateWindow (win);
  291.     }
  292.     }
  293. }
  294.  
  295. /* OpenScanStatWindow() */
  296. void OpenScanStatWindow (void)
  297. {
  298.     struct LayoutHandle * h = LT_CreateHandleTags (0, LAHN_LocaleHook, &LocaleHook, TAG_DONE);
  299.     if (h)
  300.     {    New_Horizontal_group (h, SPREAD | SAME_SIZE | FRAME);
  301.     {   New_Button (h, SCAN_NEWREF, STOP_SCANNING_LOC);
  302.         LT_EndGroup (h);
  303.     }
  304.     if (LT_Build (h,
  305.         LAWN_Title,     GetString(SCANNING_LOC),
  306.         LAWN_IDCMP,     IDCMP_GADGETUP,
  307.         WA_DepthGadget, TRUE,
  308.         WA_RMBTrap,     TRUE,
  309.         WA_DragBar,     TRUE,
  310.         WA_Activate,    TRUE,
  311.         WA_CloseGadget, TRUE,
  312.     TAG_DONE))
  313.         ScanStatPrj = h;
  314.     else
  315.         LT_DeleteHandle (ScanStatPrj);
  316.     }
  317. }
  318.  
  319. static struct LayoutHandle * OpenOptions (void)
  320. {
  321.     struct LayoutHandle * h = LT_CreateHandleTags (0, LAHN_LocaleHook, &LocaleHook, TAG_DONE);
  322.     if (h)
  323.     {    LT_New (h, LA_Type, VERTICAL_KIND, TAG_DONE);
  324.     {
  325.         New_Horizontal_group (h, FRAME | SPREAD | SAME_SIZE);
  326.         {
  327.         New_CheckBox (h, AUTODOCS, AUTODOCS_LOC);
  328.         LT_EndGroup (h);
  329.         }
  330.         New_Horizontal_group (h, SPREAD | SAME_SIZE);
  331.         {
  332.         LT_New (h, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, TAG_DONE);
  333.         {
  334.             New_CheckBox (h, C_INCLUDES, C_INCLUDES_LOC);
  335.             LT_New (h, LA_Type, XBAR_KIND, TAG_DONE);
  336.             New_CheckBox (h, DEFINES, DEFINES_LOC);
  337.             New_CheckBox (h, STRUCT_UNIONS, STRUCTUNIONS_LOC);
  338.             New_CheckBox (h, TYPEDEFS, TYPDEDEF_LOC);
  339.             LT_EndGroup (h);
  340.         }
  341.         LT_New (h, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, TAG_DONE);
  342.         {
  343.             New_CheckBox (h, E_INCLUDES, E_INCLUDES_LOC);
  344.             LT_New (h, LA_Type, XBAR_KIND, TAG_DONE);
  345.             New_CheckBox (h, CONSTANTES, CONST_LOC);
  346.             New_CheckBox (h, OBJECTS, OBJECT_LOC);
  347.             New_CheckBox (h, PROCEDURES, PROC_LOC);
  348.             LT_EndGroup (h);
  349.         }
  350.         LT_New (h, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, TAG_DONE);
  351.         {
  352.             New_CheckBox (h, ASM_INCLUDES, ASM_INCLUDES_LOC);
  353.             LT_New (h, LA_Type, XBAR_KIND, TAG_DONE);
  354.             New_CheckBox (h, EQU_BITDEF, EQUBITDEF_LOC);
  355.             New_CheckBox (h, STRUCTURES, STRUCTURE_LOC);
  356.             New_CheckBox (h, MACROS, MACRO_LOC);
  357.             LT_EndGroup (h);
  358.         }
  359.         LT_EndGroup (h);
  360.         }
  361.         LT_New (h, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, TAG_DONE);
  362.         {
  363.         New_CheckBox (h, SCAN_DRAWERS_RECURS, SCAN_RECURS_LOC);
  364.         New_CheckBox (h, TREAT_UNRECOGNIZED_FILES, UNRECOGNIZED_LOC);
  365.         New_CheckBox (h, KEEP_FILES, KEEP_FILES_LOC);
  366.         LT_EndGroup (h);
  367.         }
  368.         LT_New (h, LA_Type, VERTICAL_KIND, LAGR_Frame, TRUE, TAG_DONE);
  369.         {
  370.         New_Horizontal_group (h, SPREAD | SAME_SIZE);
  371.         {
  372.             New_Button (h, LOAD_OPT, LOADPREFS_LOC);
  373.             New_Button (h, LASTSAVED, LASTSAVED_LOC);
  374.             New_Button (h, CANCEL_OPT, CANCEL_LOC);
  375.             LT_EndGroup (h);
  376.         }
  377.         New_Horizontal_group (h, SPREAD | SAME_SIZE);
  378.         {
  379.             New_Button (h, SAVEAS_OPT, SAVEAS_LOC);
  380.             New_Button (h, SAVE_OPT, SAVE_REFS_LOC);
  381.             New_Button (h, USE_OPT, USEREFS_LOC);
  382.             LT_EndGroup (h);
  383.         }
  384.         LT_EndGroup (h);
  385.         }
  386.         LT_EndGroup (h);
  387.     }
  388.     if (! LT_Build (h,
  389.         LAWN_Title,     GetString(GEN_OPT_LOC),
  390.         LAWN_IDCMP,     IDCMP_CLOSEWINDOW | IDCMP_GADGETUP,
  391.         WA_DepthGadget, TRUE,
  392.         WA_RMBTrap,     TRUE,
  393.         WA_DragBar,     TRUE,
  394.         WA_Activate,    TRUE,
  395.         WA_CloseGadget, TRUE,
  396.     TAG_DONE))
  397.     {
  398.         LT_DeleteHandle (h);
  399.         h = 0;
  400.     }
  401.     }
  402.     return h;
  403. }
  404.  
  405. /* CloseScanStatWindow() */
  406. void CloseScanStatWindow (void)
  407. {
  408.     if (ScanStatPrj)
  409.     LT_DeleteHandle (ScanStatPrj);
  410.     ScanStatPrj = NULL;
  411. }
  412.  
  413. /// GiveHelp() - open guide positioned at the help for <id>
  414. #include "HelpTable.h"
  415.  
  416. void
  417. GiveHelp(LONG id, struct Screen *scr)
  418. {
  419.     struct Library *AmigaGuideBase;
  420.     struct NewAmigaGuide nag = { NULL };
  421.     AMIGAGUIDECONTEXT handle;
  422.     LONG cnt;
  423.  
  424.     LockGUI();
  425.  
  426.     nag.nag_Name = "FetchRefs_GI.guide";
  427.     nag.nag_Screen = scr;
  428.  
  429.     for (cnt = 0; HelpTable[cnt].id; cnt++)
  430.     if (HelpTable[cnt].id == id)
  431.         break;
  432.     nag.nag_Node = HelpTable[cnt].node;
  433.     nag.nag_Line = HelpTable[cnt].line;
  434.  
  435.     /* Show the guide */
  436.     if (AmigaGuideBase = OpenLibrary("amigaguide.library", 34))
  437.     {
  438.     if (handle = OpenAmigaGuideA(&nag, NULL))
  439.         CloseAmigaGuide(handle);
  440.     else
  441.         PostMessage ("Could not open guide");
  442.  
  443.     CloseLibrary(AmigaGuideBase);
  444.     } else
  445.     PostMessage ("Could not open amigaguide.library v34+");
  446.  
  447.     UnlockGUI();
  448. }
  449.  
  450. /* LockGUI() */
  451. void LockGUI (void)
  452. {
  453.     if (MainPrj)
  454.     LT_LockWindow (MainPrj->Window);
  455.     if (RefPrj)
  456.     LT_LockWindow (RefPrj->Window);
  457.     if (OptionsPrj)
  458.     LT_LockWindow (OptionsPrj->Window);
  459. }
  460.  
  461. /* UnlockGUI() */
  462. void UnlockGUI (void)
  463. {
  464.     if (MainPrj)
  465.     LT_DeleteWindowLock (MainPrj->Window);
  466.     if (RefPrj)
  467.     LT_DeleteWindowLock (RefPrj->Window);
  468.     if (OptionsPrj)
  469.     LT_DeleteWindowLock (OptionsPrj->Window);
  470. }
  471.  
  472. /* AttachMainList() */
  473. void AttachMainList (struct List *newlist)
  474. {
  475.     static struct List *lastlist = &FileList;
  476.  
  477.     if (!newlist)
  478.     newlist = lastlist;
  479.     else
  480.     lastlist = newlist;
  481.  
  482.     if (MainPrj)
  483.     {
  484.     LT_SetAttributes (MainPrj, LISTE_REFERENCES, GTLV_Labels, newlist, GTLV_Selected, 0, TAG_END);
  485.  
  486.     if (newlist == &FileList)
  487.         UpdateMain();
  488.     }
  489. }
  490.  
  491. /* DetachMainList() */
  492. void DetachMainList (void)
  493. {
  494.     if (MainPrj)
  495.     LT_SetAttributes (MainPrj, LISTE_REFERENCES, GTLV_Labels, ~0, TAG_END);
  496. }
  497.  
  498. /* AttachRefList() */
  499. void AttachRefList (void)
  500. {
  501.     struct FileEntry *f;
  502.  
  503.     if (RefPrj)
  504.     {
  505.     f = SelectedMain();
  506.     LT_SetAttributes (RefPrj, INPUT_REFERENCES, GTLV_Labels, (ULONG) (f ? &f->data.RefsList : &EmptyList), TAG_END);
  507.     }
  508. }
  509.  
  510. /* DetachRefList() */
  511. void DetachRefList (void)
  512. {
  513.     if (RefPrj)
  514.     LT_SetAttributes (RefPrj, INPUT_REFERENCES, GTLV_Labels, ~0, TAG_END);
  515. }
  516.  
  517. /* DeleteSelectedFile() */
  518. static void DeleteSelectedFile (void)
  519. {
  520.     struct FileEntry *f;
  521.  
  522.     if (f = SelectedMain())
  523.     {
  524.     DetachMainList ();
  525.     FreeFile (f);
  526.     AttachMainList (NULL);
  527.     UpdateMain ();
  528.  
  529.     FileChanged = TRUE;
  530.     }
  531. }
  532.  
  533. /* DeleteSelectedReference() */
  534. void DeleteSelectedReference (void)
  535. {
  536.     struct RefsEntry *r;
  537.  
  538.     if (r = SelectedRef())
  539.     {
  540.     FreeRef (r);
  541.     FileChanged = TRUE;
  542.     }
  543. }
  544.  
  545. /* RescanAllFiles() */
  546. static void RescanAllFiles (void)
  547. {
  548.     struct Node *n, *next;
  549.  
  550.     for (next = GetHead (&FileList);  n = next, next = next->ln_Succ;  )
  551.     {
  552.     /* If the user break (window is closed) the list is not sorted
  553.      * so we do that before returning. */
  554.     if (! ScanStatPrj)
  555.     {
  556.         SortExecList (&FileList, SortCompareFunc, NULL);
  557.         break;
  558.     }
  559.  
  560.     /* Rescan this one. This may delete the entry, so we have cached
  561.      * a pointer to the next. */
  562.     IndexFile ("", n->ln_Name);
  563.     }
  564. }
  565.  
  566. /* UpdateMain() */
  567. void UpdateMain (void)
  568. {
  569.     struct FileEntry *n = SelectedMain();
  570.     static char val[10];
  571.     ULONG nf;
  572.  
  573.     /* Update main windows action gadgets: no list, no action */
  574.     if (MainPrj)
  575.     {
  576.     LT_SetAttributes (MainPrj, DELETE_FILE, GA_Disabled, !n, TAG_END);
  577.     LT_SetAttributes (MainPrj, RESCAN_REF, GA_Disabled, !n, TAG_END);
  578.     LT_SetAttributes (MainPrj, RESCAN_ALL, GA_Disabled, !n, TAG_END);
  579.  
  580.     /* Update main 'references count' gadget */
  581.     if (n)
  582.         nf =  NumOfNodes(&n->data.RefsList);
  583.     else
  584.         nf = 0;
  585.     sprintf (val, "%ld", nf);
  586.     LT_SetAttributes (MainPrj, NBRE_REFERENCES, GTTX_Text, val, TAG_END);
  587.     LT_SetAttributes (MainPrj, SAVE_REFS, GA_Disabled, !nf, TAG_END);
  588.     LT_SetAttributes (MainPrj, CLEAR, GA_Disabled, !nf, TAG_END);
  589.     }
  590.  
  591.     /* Update ref 'file' gadget */
  592.     if (RefPrj)
  593.     {
  594.     LT_SetAttributes (RefPrj, REF_FILE, GTTX_Text, (ULONG) (n ? (STRPTR)n->data.Name : (STRPTR)""), TAG_END);
  595.     UpdateRef();
  596.     }
  597. }
  598.  
  599. /* UpdateRef() */
  600. void UpdateRef (void)
  601. {
  602.     static struct FileEntry *shown = (APTR)-1;
  603.     static char offset[10], size[10], line[10];
  604.  
  605.     if (RefPrj)
  606.     {
  607.     struct FileEntry *f = SelectedMain();
  608.     struct RefsEntry *r = SelectedRef();
  609.  
  610.     /* Update ref window 'delete' gadget */
  611.     LT_SetAttributes (RefPrj, DELETE_REF, GA_Disabled, !r, TAG_END);
  612.  
  613.     /* Update ref window's listview if main window is changed */
  614.     if (f != shown)
  615.     {
  616.         LT_SetAttributes (RefPrj, INPUT_REFERENCES, GTLV_Labels, ~0, TAG_END);
  617.         AttachRefList();
  618.     }
  619.  
  620.     /* Update ref windows information gadgets */
  621.     sprintf (offset, "%ld", r ? r->data.Offset : 0);
  622.     LT_SetAttributes (RefPrj, OFFSET, GTTX_Text, offset, TAG_END);
  623.     sprintf (size, "%ld", r ? r->data.Length : 0);
  624.     LT_SetAttributes (RefPrj, SIZE, GTTX_Text, size, TAG_END);
  625.     sprintf (line, "%ld", r ? r->data.Goto : 0);
  626.     LT_SetAttributes (RefPrj, LINE, GTTX_Text, line, TAG_END);
  627.  
  628.     shown = f;
  629.     }
  630.     else
  631.     shown = (APTR)-1;
  632. }
  633.  
  634. /* UpdateOptions() */
  635. void UpdateOptions (void)
  636. {
  637.     LT_SetAttributes (OptionsPrj, AUTODOCS, GTCB_Checked, Settings.AutoDocPrf.Active, TAG_END);
  638.  
  639.     LT_SetAttributes (OptionsPrj, C_INCLUDES, GTCB_Checked, Settings.CPrf.Active, TAG_END);
  640.     LT_SetAttributes (OptionsPrj, DEFINES, GTCB_Checked, Settings.CPrf.Define, TAG_END);
  641.     LT_SetAttributes (OptionsPrj, STRUCT_UNIONS, GTCB_Checked, Settings.CPrf.Struct, TAG_END);
  642.     LT_SetAttributes (OptionsPrj, TYPEDEFS, GTCB_Checked, Settings.CPrf.Typedef, TAG_END);
  643.  
  644.     LT_SetAttributes (OptionsPrj, E_INCLUDES, GTCB_Checked, Settings.EPrf.Active, TAG_END);
  645.     LT_SetAttributes (OptionsPrj, CONSTANTES, GTCB_Checked, Settings.EPrf.Const, TAG_END);
  646.     LT_SetAttributes (OptionsPrj, OBJECTS, GTCB_Checked, Settings.EPrf.Object, TAG_END);
  647.     LT_SetAttributes (OptionsPrj, PROCEDURES, GTCB_Checked, Settings.EPrf.Proc, TAG_END);
  648.  
  649.     LT_SetAttributes (OptionsPrj, ASM_INCLUDES, GTCB_Checked, Settings.AsmPrf.Active, TAG_END);
  650.     LT_SetAttributes (OptionsPrj, EQU_BITDEF, GTCB_Checked, Settings.AsmPrf.Equ, TAG_END);
  651.     LT_SetAttributes (OptionsPrj, STRUCTURES, GTCB_Checked, Settings.AsmPrf.Structure, TAG_END);
  652.     LT_SetAttributes (OptionsPrj, MACROS, GTCB_Checked, Settings.AsmPrf.Macro, TAG_END);
  653.  
  654.     LT_SetAttributes (OptionsPrj, SCAN_DRAWERS_RECURS, GTCB_Checked, Settings.Recursively, TAG_END);
  655.     LT_SetAttributes (OptionsPrj, KEEP_FILES, GTCB_Checked, Settings.KeepEmpty, TAG_END);
  656.     LT_SetAttributes (OptionsPrj, TREAT_UNRECOGNIZED_FILES, GTCB_Checked, Settings.UnknownAsAutoDoc, TAG_END);
  657.  
  658.     UpdateOptionsGhost();
  659. }
  660.  
  661. /* UpdateOptionsGhost() */
  662. void UpdateOptionsGhost (void)
  663. {
  664.     LONG ghost;
  665.  
  666.     if (! OptionsPrj)
  667.     return;
  668.  
  669.     ghost = ! LT_GetAttributes (OptionsPrj, C_INCLUDES, TAG_DONE);
  670.     LT_SetAttributes (OptionsPrj, DEFINES, GA_Disabled, ghost, TAG_DONE);
  671.     LT_SetAttributes (OptionsPrj, STRUCT_UNIONS, GA_Disabled, ghost, TAG_DONE);
  672.     LT_SetAttributes (OptionsPrj, TYPEDEFS, GA_Disabled, ghost, TAG_DONE);
  673.  
  674.     ghost = ! LT_GetAttributes (OptionsPrj, E_INCLUDES, TAG_DONE);
  675.     LT_SetAttributes (OptionsPrj, CONSTANTES, GA_Disabled, ghost, TAG_DONE);
  676.     LT_SetAttributes (OptionsPrj, OBJECTS, GA_Disabled, ghost, TAG_DONE);
  677.     LT_SetAttributes (OptionsPrj, PROCEDURES, GA_Disabled, ghost, TAG_DONE);
  678.  
  679.     ghost = ! LT_GetAttributes (OptionsPrj, ASM_INCLUDES, TAG_DONE);
  680.     LT_SetAttributes (OptionsPrj, EQU_BITDEF, GA_Disabled, ghost, TAG_DONE);
  681.     LT_SetAttributes (OptionsPrj, STRUCTURES, GA_Disabled, ghost, TAG_DONE);
  682.     LT_SetAttributes (OptionsPrj, MACROS, GA_Disabled, ghost, TAG_DONE);
  683. }
  684.  
  685. /* UpdateSettingsStruct() */
  686. void UpdateSettingsStruct (void)
  687. {
  688.     Settings.AutoDocPrf.Active    = LT_GetAttributes (OptionsPrj, AUTODOCS, TAG_DONE);
  689.  
  690.     Settings.CPrf.Active    = LT_GetAttributes (OptionsPrj, C_INCLUDES, TAG_DONE);
  691.     Settings.CPrf.Define    = LT_GetAttributes (OptionsPrj, DEFINES, TAG_DONE);
  692.     Settings.CPrf.Struct    = LT_GetAttributes (OptionsPrj, STRUCT_UNIONS, TAG_DONE);
  693.     Settings.CPrf.Typedef    = LT_GetAttributes (OptionsPrj, TYPEDEFS, TAG_DONE);
  694.  
  695.     Settings.EPrf.Active    = LT_GetAttributes (OptionsPrj, E_INCLUDES, TAG_DONE);
  696.     Settings.EPrf.Const     = LT_GetAttributes (OptionsPrj, CONSTANTES, TAG_DONE);
  697.     Settings.EPrf.Object    = LT_GetAttributes (OptionsPrj, OBJECTS, TAG_DONE);
  698.     Settings.EPrf.Proc        = LT_GetAttributes (OptionsPrj, PROCEDURES, TAG_DONE);
  699.  
  700.     Settings.AsmPrf.Active    = LT_GetAttributes (OptionsPrj, ASM_INCLUDES, TAG_DONE);
  701.     Settings.AsmPrf.Equ     = LT_GetAttributes (OptionsPrj, EQU_BITDEF, TAG_DONE);
  702.     Settings.AsmPrf.Structure    = LT_GetAttributes (OptionsPrj, STRUCTURES, TAG_DONE);
  703.     Settings.AsmPrf.Macro    = LT_GetAttributes (OptionsPrj, MACROS, TAG_DONE);
  704.  
  705.     Settings.Recursively    = LT_GetAttributes (OptionsPrj, SCAN_DRAWERS_RECURS, TAG_DONE);
  706.     Settings.KeepEmpty        = LT_GetAttributes (OptionsPrj, KEEP_FILES, TAG_DONE);
  707.     Settings.UnknownAsAutoDoc    = LT_GetAttributes (OptionsPrj, TREAT_UNRECOGNIZED_FILES, TAG_DONE);
  708. }
  709.  
  710. void __regargs HandleReferencesPrj (struct IntuiMessage * msg)
  711. {
  712.     struct Gadget * gad = (struct Gadget *) msg->IAddress;
  713.  
  714.     switch (msg->Class)
  715.     {
  716.     case IDCMP_CLOSEWINDOW:
  717.         LT_DeleteHandle (RefPrj);
  718.         RefPrj = NULL;
  719.         /* Forget what the listview contains */
  720.         UpdateRef();
  721.         break;
  722.     case IDCMP_IDCMPUPDATE:
  723.         UpdateRef ();
  724.         break;
  725.     case IDCMP_GADGETUP:
  726.         switch (gad->GadgetID)
  727.         {
  728.         case INPUT_REFERENCES:
  729.             UpdateRef ();
  730.             break;
  731.         case DELETE_REF:
  732.             DeleteSelectedReference();
  733.             UpdateMain();
  734.             break;
  735.         }
  736.     }
  737. }
  738.  
  739. BOOL __regargs HandleMainprj (struct IntuiMessage * msg)
  740. {
  741.     struct Gadget * gad = (struct Gadget *) msg->IAddress;
  742.  
  743.     switch (msg->Class)
  744.     {
  745.     case IDCMP_IDCMPUPDATE:
  746.         switch (gad->GadgetID)
  747.         {    case LISTE_REFERENCES:
  748.         case NBRE_REFERENCES:
  749.             OpenReferencesWindow ();    break;
  750.         }
  751.         break;
  752.     case IDCMP_GADGETUP:
  753.         switch (gad->GadgetID)
  754.         {
  755.         case SCAN_NEWREF:
  756.             {
  757.             struct rtFileList * selfiles;
  758.             char tmpname[108];
  759.  
  760.             LockGUI();
  761.             tmpname[0] = 0;
  762.             if (selfiles = rtFileRequest (AddFileReq, tmpname,
  763.                 GetString(SELECT_INDEXFILES_LOC),
  764.                 RTFI_Flags, FREQF_MULTISELECT | FREQF_SELECTDIRS | FREQF_PATGAD,
  765.                 TAG_END))
  766.             {
  767.                 StartScanning ();
  768.                 IndexFileList (AddFileReq->Dir, selfiles);
  769.                 rtFreeFileList (selfiles);
  770.                 SortExecList (&FileList, SortCompareFunc, NULL);
  771.                 StopScanning (FALSE);
  772.             }
  773.             UnlockGUI();
  774.             }
  775.             break;
  776.         case RESCAN_REF:
  777.             {
  778.             struct FileEntry *f;
  779.  
  780.             if (f = SelectedMain())
  781.             {
  782.                 StartScanning();
  783.                 LockGUI ();
  784.  
  785.                 /* Rescan. This will free the old references */
  786.                 IndexFile ("", f->data.Name);
  787.  
  788.                 UnlockGUI();
  789.                 StopScanning (FALSE);
  790.             }
  791.             }
  792.             break;
  793.  
  794.         case RESCAN_ALL:
  795.             StartScanning();
  796.             LockGUI();
  797.             RescanAllFiles();
  798.             UnlockGUI();
  799.             StopScanning (FALSE);
  800.             break;
  801.  
  802.         case DELETE_FILE:
  803.             DeleteSelectedFile();       break;
  804.  
  805.         case QUIT:
  806.             return 0;
  807.  
  808.         case LISTE_REFERENCES:
  809.             UpdateMain ();
  810.             break;
  811.  
  812.         case LOAD_REFS:
  813.             LockGUI();
  814.             if ((!FileChanged) || rtEZRequestTags (GetString(LOOSE_CHANGES_LOC),
  815.                     GetString (OK_CANCEL_LOC),  NULL, NULL,
  816.                     RT_Underscore, '_', TAG_END))
  817.             {
  818.             if (! IsListEmpty (&FileList))
  819.             {
  820.                 ULONG ret;
  821.                 ret = rtEZRequestTags (GetString (NOEMPTYLIST_LOC),
  822.                     GetString (REPLACE_APPEND_LOC), NULL, NULL,
  823.                     RT_Underscore, '_',     TAG_END);
  824.  
  825.                 if (ret == 0)
  826.                 {
  827.                 UnlockGUI ();
  828.                 break;
  829.                 }
  830.                 else if (ret == 1)
  831.                 {
  832.                 InitializeFileList ();
  833.                 UpdateMain ();
  834.  
  835.                 FileChanged = FALSE;
  836.                 }
  837.                 else if (ret == 2)
  838.                 FileChanged = TRUE;
  839.             }
  840.             else
  841.                 FileChanged = FALSE;
  842.  
  843.             LoadData (NULL);
  844.             UpdateMain ();
  845.             }
  846.             UnlockGUI();
  847.             break;
  848.  
  849.         case SAVE_REFS:
  850.             if (! IsListEmpty (&FileList))
  851.             {
  852.             LockGUI ();
  853.             SaveData (NULL);
  854.             UnlockGUI ();
  855.             }
  856.             break;
  857.  
  858.         case CLEAR:
  859.             LockGUI();
  860.             if ((!FileChanged) || rtEZRequestTags (GetString(CLEAR_LIST_LOC),
  861.                 GetString (OK_CANCEL_LOC), NULL, NULL,
  862.                 RT_Underscore, '_',     TAG_END))
  863.             {
  864.             InitializeFileList();
  865.             UpdateMain();
  866.  
  867.             FileChanged = FALSE;
  868.             }
  869.             UnlockGUI();
  870.             break;
  871.  
  872.         case OPTIONS:
  873.             if (! OptionsPrj)
  874.             {
  875.             LT_SetAttributes (MainPrj, SCAN_NEWREF, GA_Disabled, TRUE, TAG_END);
  876.             if (OptionsPrj = OpenOptions ())
  877.                 UpdateOptions();
  878.             else
  879.                 LT_SetAttributes (MainPrj, SCAN_NEWREF, GA_Disabled, FALSE, TAG_END);
  880.             }
  881.             else
  882.             {
  883.             struct Window *win;
  884.  
  885.             /* Bring the options window to the front */
  886.             if (win = OptionsPrj->Window)
  887.             {
  888.                 WindowToFront (win);
  889.                 ActivateWindow (win);
  890.                 // TR_ReleaseWindow(win);
  891.             }
  892.             }
  893.             break;
  894.         case INFOS:
  895.             LockGUI();
  896.             About();
  897.             UnlockGUI();
  898.             break;
  899.         }
  900.         break;
  901.     case IDCMP_CLOSEWINDOW:
  902.         return 0;
  903.     }
  904.     return 1;
  905. }
  906.  
  907. /* HandleOptionsPrj () */
  908. void HandleOptionsPrj (struct IntuiMessage * m)
  909. {
  910.     static UBYTE prefname[108];
  911.     struct Prefs tmpsettings;
  912.     BPTR newdir, olddir;
  913.  
  914.     if (m->Class == IDCMP_CLOSEWINDOW)
  915.     {
  916.     LT_DeleteHandle (OptionsPrj);
  917.     OptionsPrj = NULL;
  918.     LT_SetAttributes (MainPrj, SCAN_NEWREF, GA_Disabled, FALSE, TAG_END);
  919.     return;
  920.     }
  921.  
  922.     if (m->Class == IDCMP_GADGETUP)
  923.     {
  924.     struct Gadget * gad = (struct Gadget *) m->IAddress;
  925.  
  926.     switch (gad->GadgetID)
  927.     {
  928.         case USE_OPT:
  929.         case SAVE_OPT:
  930.         UpdateSettingsStruct ();
  931.  
  932.         if (gad->GadgetID == SAVE_OPT)
  933.             SaveSettings ("ENVARC:FetchRefs_GI.prefs");
  934.         SaveSettings ("ENV:FetchRefs_GI.prefs");
  935.  
  936.         case CANCEL_OPT:
  937.         LT_DeleteHandle (OptionsPrj);
  938.         OptionsPrj = NULL;
  939.         LT_SetAttributes (MainPrj, SCAN_NEWREF, GA_Disabled, FALSE, TAG_END);
  940.         break;
  941.  
  942.         case SAVEAS_OPT:
  943.         if (rtFileRequest (PrefsFileReq, prefname, "Save settings...",
  944.                   RTFI_Flags, FREQF_SAVE,    TAG_END))
  945.         {
  946.             if (newdir = Lock (PrefsFileReq->Dir, SHARED_LOCK))
  947.             {
  948.  
  949.             /* As SaveSettings() uses the 'Settings' struct we
  950.              * need to fill it with the current settings even
  951.              * though they may still be Cancel'ed. Therefore we
  952.              * copy the original back. */
  953.             CopyMem (&Settings, &tmpsettings, sizeof(struct Prefs));
  954.             UpdateSettingsStruct ();
  955.             olddir = CurrentDir (newdir);
  956.             SaveSettings (prefname);
  957.             CurrentDir (olddir);
  958.             UnLock (newdir);
  959.             CopyMem (&tmpsettings, &Settings, sizeof(struct Prefs));
  960.             }
  961.         }
  962.         break;
  963.  
  964.         case LASTSAVED:
  965.         /* We copy to 'tmpsettings' to be able to restore the
  966.          * original settings if Cancel is chosen. */
  967.         CopyMem (&Settings, &tmpsettings, sizeof(struct Prefs));
  968.         LoadSettings ("ENVARC:FetchRefs_GI.prefs");
  969.         UpdateOptions ();
  970.         CopyMem (&tmpsettings, &Settings, sizeof(struct Prefs));
  971.         break;
  972.  
  973.         case LOAD_OPT:
  974.         if (rtFileRequest (PrefsFileReq, prefname, "Load settings...", TAG_END))
  975.         {
  976.             if (newdir = Lock (PrefsFileReq->Dir, SHARED_LOCK))
  977.             {
  978.             /* We copy to 'tmpsettings' to be able to restore the
  979.              * original settings if Cancel is chosen. By using a
  980.              * temporary variable only the state of the gadgets
  981.              * is changed. The change is not permanent until Use
  982.              * or Save is chosen. */
  983.             CopyMem (&Settings, &tmpsettings, sizeof(struct Prefs));
  984.             olddir = CurrentDir (newdir);
  985.             LoadSettings (prefname);
  986.             CurrentDir (olddir);
  987.             UnLock (newdir);
  988.             UpdateOptions ();
  989.             CopyMem (&tmpsettings, &Settings, sizeof(struct Prefs));
  990.             }
  991.         }
  992.         break;
  993.  
  994.         case AUTODOCS:
  995.         case C_INCLUDES:
  996.         case E_INCLUDES:
  997.         case ASM_INCLUDES:
  998.         UpdateOptionsGhost ();
  999.         break;
  1000.     }
  1001.     }
  1002. }
  1003.  
  1004. /* HandleGUI() */
  1005. void HandleGUI (void)
  1006. {
  1007.     struct IntuiMessage * Message, msg;
  1008.     ULONG classe;
  1009.  
  1010.     if (ScanStatPrj)
  1011.     {
  1012.     while (Message = LT_GetIMsg (ScanStatPrj))
  1013.     {   classe = Message->Class;
  1014.         LT_ReplyIMsg (Message);
  1015.         if (classe == IDCMP_GADGETUP)
  1016.         {    StopScanning (TRUE);    break;  }
  1017.     }
  1018.     }
  1019.  
  1020.     while (Message = LT_GetIMsg (MainPrj))
  1021.     {
  1022.     memcpy (&msg, Message, sizeof(struct IntuiMessage));
  1023.     LT_ReplyIMsg (Message);
  1024.     if (! HandleMainprj (&msg))
  1025.         GoOn = 0;
  1026.     }
  1027.     if (RefPrj)
  1028.     while (Message = LT_GetIMsg (RefPrj))
  1029.     {
  1030.         memcpy (&msg, Message, sizeof(struct IntuiMessage));
  1031.         LT_ReplyIMsg (Message);
  1032.         HandleReferencesPrj (&msg);
  1033.         if (! RefPrj)
  1034.         break;
  1035.     }
  1036.  
  1037.     if (OptionsPrj)
  1038.     while (Message = LT_GetIMsg (OptionsPrj))
  1039.     {
  1040.         memcpy (&msg, Message, sizeof(struct IntuiMessage));
  1041.         LT_ReplyIMsg (Message);
  1042.         HandleOptionsPrj (&msg);
  1043.         if (! OptionsPrj)
  1044.         break;
  1045.     }
  1046.  
  1047.     /* struct TR_Message *msg;
  1048.  
  1049.     while (msg = TR_GetMsg(Application))
  1050.     {
  1051.     if (msg->trm_Class == TRMS_HELP)
  1052.     {
  1053.         struct Window *win;
  1054.         struct Screen *scr;
  1055.  
  1056.         if (win = MainPrj->Window)
  1057.         {
  1058.         scr = win->WScreen;
  1059.         TR_ReleaseWindow (win);
  1060.         } else
  1061.         scr = NULL;
  1062.  
  1063.         GiveHelp (msg->trm_ID, scr);
  1064.     }
  1065.     } */
  1066.  
  1067.     /* Make sure that the user wants to quit */
  1068.     if ((! GoOn)  &&  (FileChanged))
  1069.     {
  1070.     LONG val;
  1071.  
  1072.     LockGUI();
  1073.     val = rtEZRequestTags ("There are changes!\nReally quit?",
  1074.         "_Save and quit|_Quit|_Cancel",
  1075.         NULL, NULL, RT_Underscore, '_', TAG_END);
  1076.  
  1077.     if (val == 0)
  1078.         GoOn = TRUE;
  1079.     else if (val == 1)
  1080.     {
  1081.         if (!SaveData(NULL))
  1082.         GoOn = TRUE;
  1083.     }
  1084.     UnlockGUI();
  1085.     }
  1086. }
  1087.  
  1088. /* NumOfNodes() */
  1089. ULONG NumOfNodes (struct List *l)
  1090. {
  1091.     struct Node * n = GetHead (l);
  1092.     ULONG cnt = 0;
  1093.  
  1094.     while (n->ln_Succ)
  1095.     {
  1096.     cnt++;
  1097.     n = n->ln_Succ;
  1098.     }
  1099.     return cnt;
  1100. }
  1101.  
  1102. /* SelectedMain() */
  1103. struct FileEntry * SelectedMain (void)
  1104. {
  1105.     struct FileEntry * f = 0;
  1106.  
  1107.     /* Find pointer to selected node in main listview */
  1108.     if (! IsListEmpty (&FileList))
  1109.     {
  1110.     long cnt = LT_GetAttributes (MainPrj, LISTE_REFERENCES, TAG_DONE);
  1111.     if (cnt >= 0)
  1112.     {
  1113.         f = (struct FileEntry *) GetHead (&FileList);
  1114.         while (cnt--)
  1115.         f = GetSucc (f);
  1116.     }
  1117.     }
  1118.     return f;
  1119. }
  1120.  
  1121. /* SelectedRef() */
  1122. struct RefsEntry * SelectedRef (void)
  1123. {
  1124.     struct FileEntry * f = SelectedMain();
  1125.     struct RefsEntry * r = 0;
  1126.  
  1127.     /* Find pointer to selected node in main listview */
  1128.     if ((f != NULL) && (! IsListEmpty(&f->data.RefsList)))
  1129.     {
  1130.     long cnt = LT_GetAttributes (RefPrj, INPUT_REFERENCES, TAG_DONE);
  1131.     if (cnt >= 0)
  1132.     {
  1133.         r = (struct RefsEntry *) GetHead (&f->data.RefsList);
  1134.         while (cnt--)
  1135.         r = GetSucc (r);
  1136.     }
  1137.     }
  1138.     return r;
  1139. }
  1140.  
  1141. /* GoGUI() */
  1142. void GoGUI (void)
  1143. {
  1144.     ULONG signaux;
  1145.  
  1146.     if (DataFileReq = rtAllocRequestA (RT_FILEREQ, NULL))
  1147.     {
  1148.     if (AddFileReq = rtAllocRequestA (RT_FILEREQ, NULL))
  1149.     {
  1150.         rtChangeReqAttr (AddFileReq, RTFI_MatchPat, "~(#?.(guide|a|c|e|o))", TAG_END);
  1151.  
  1152.         if (PrefsFileReq = rtAllocRequestA (RT_FILEREQ, NULL))
  1153.         {
  1154.         /* Load a data file if any is specified by tool types/Shell arguments */
  1155.         if (DataName[0])
  1156.         {
  1157.             STRPTR p;
  1158.  
  1159.             LoadData (DataName);
  1160.             p = PathPart (DataName);
  1161.  
  1162.             /* If a path is specified we split up in path and file name */
  1163.             if (p  !=  DataName)
  1164.             {
  1165.             UBYTE c = *p;
  1166.             *p = 0;
  1167.             rtChangeReqAttr (DataFileReq, RTFI_Dir, DataName, TAG_END);
  1168.             *p = c;
  1169.             strcpy (DataName, FilePart(DataName));
  1170.             }
  1171.         }
  1172.  
  1173.         MainPrj = CreateMainWindow ();
  1174.         if (MainPrj)
  1175.         {
  1176.             UpdateMain ();
  1177.  
  1178.             while (GoOn)
  1179.             {    signaux = (1 << MainPrj->Window->UserPort->mp_SigBit);
  1180.             if (ScanStatPrj)
  1181.                 signaux |= (1 << ScanStatPrj->Window->UserPort->mp_SigBit);
  1182.             if (OptionsPrj)
  1183.                 signaux |= (1 << OptionsPrj->Window->UserPort->mp_SigBit);
  1184.             if (RefPrj)
  1185.                 signaux |= (1 << RefPrj->Window->UserPort->mp_SigBit);
  1186.             Wait (signaux);
  1187.             HandleGUI ();
  1188.             }
  1189.             LT_DeleteHandle (MainPrj);
  1190.             MainPrj = 0;
  1191.         }
  1192.         }
  1193.     }
  1194.     }
  1195.     CloseGUI ();
  1196. }
  1197.  
  1198. /* CloseGUI() */
  1199. void CloseGUI (void)
  1200. {
  1201.     if (ReqToolsBase)
  1202.     {
  1203.     rtFreeRequest (DataFileReq);
  1204.     rtFreeRequest (AddFileReq);
  1205.     rtFreeRequest (PrefsFileReq);
  1206.     }
  1207.  
  1208.     if (GTLayoutBase)
  1209.     {
  1210.     if (MainPrj)
  1211.         LT_DeleteHandle (MainPrj);
  1212.     if (RefPrj)
  1213.         LT_DeleteHandle (RefPrj);
  1214.     if (OptionsPrj)
  1215.         LT_DeleteHandle (OptionsPrj);
  1216.     }
  1217. }
  1218.