home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 552.lha / Browser_II_v1.0 / source.LZH / source / BrowserII.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-21  |  10.3 KB  |  422 lines
  1. /*
  2.  *    BrowserII.c - Copyright © 1991 by S.R. & P.C.
  3.  *
  4.  *    Created:    16 Feb 1991  11:00:11
  5.  *    Modified:    21 Jul 1991  17:19:32
  6.  *
  7.  *    Make>> make
  8.  */
  9.  
  10. #include "Global.h"
  11. #include "FileList.h"
  12. #include "Process.h"
  13. #include "proto/Windows.h"
  14. #include "proto/Mouse.h"
  15. #include "proto/Config.h"
  16. #include "proto/Menus.h"
  17. #include "proto/Process.h"
  18. #include "proto/Run.h"
  19. #include "proto/Scan.h"
  20. #include "proto/String.h"
  21. #include "proto/Request.h"
  22. #include "proto/Sort.h"
  23. #include "proto/Draw.h"
  24. #include "proto/ActionBack.h"
  25.  
  26. extern void setmem(void *mem, size_t size, long value);
  27.  
  28.  
  29. #define THE_END            0
  30. #define NO_MAINPORT        1
  31. #define NO_PROCESSPORT    2
  32. #define NO_WIN            3
  33. #define NO_DEVS            4
  34.  
  35.  
  36. /*****                  global variables                    *****/
  37.  
  38.  
  39. extern struct IntuitionBase *IntuitionBase;
  40. extern struct Process *MainProcess;
  41. extern struct MsgPort *MainPort;
  42. extern struct MsgPort *ProcessPort;
  43. extern struct MinList WindowList;
  44. extern struct Screen *Screen;
  45. extern struct BrowserWindow *CurrentWin;
  46. extern struct Config Config;
  47. extern struct ParMConfig ParMConfig;
  48. extern struct Menu Menu1;
  49. extern short NumProcess;
  50. extern char *ReqTitle;
  51. extern BOOL CustomScreen;
  52. extern BPTR BrowserDir;
  53.  
  54.  
  55. /*****                  local variables                    *****/
  56.  
  57. static APTR OldWindowPtr;
  58. static BOOL DoNextSelect;
  59.  
  60. static void Bye(short);
  61. static void Rescan(void);
  62. static void AffectAll(void);
  63. static void Filters(short);
  64. static void OpenDir(void);
  65. static void UpdateMenus(void);
  66.  
  67.  
  68. static void (*FMenu0[])() = {UpdateMenus, CmdMode, DoCommand, ScreenType, RunMode, CopyMode, CopyFlags, DisplayDevs, Options, SaveConfig, Bye};
  69. static void (*FMenu1[])() = {Rescan, OpenParent, OpenDir, SelectMatch, SelectAll, Filters, FileInfo, SortBy, AffectAll};
  70.  
  71. static void (**MenuFunct[])() = {FMenu0, FMenu1};
  72.  
  73.  
  74. /*****                        code                        *****/
  75.  
  76.  
  77. void CheckMenus(void)
  78. {
  79.     struct MenuFlags *MenuFlags;
  80.     BOOL Refresh = FALSE;
  81.  
  82.     MenuFlags = GetMenuFlags();
  83.     if (MenuFlags->NewDevs) {
  84.         MenuFlags->NewDevs = FALSE;
  85.         ScanDevs();
  86.     }
  87.     if (CurrentWin->bw_Sort != MenuFlags->OldSort && CurrentWin->bw_Type != BW_MAIN) {
  88.         MenuFlags->OldSort = CurrentWin->bw_Sort;
  89.         Sort(CurrentWin);
  90.         Refresh = TRUE;
  91.     }
  92.     if (CurrentWin->bw_EntryInfoFlags != MenuFlags->OldFileInfo && CurrentWin->bw_Type != BW_MAIN) {
  93.         MenuFlags->OldFileInfo = CurrentWin->bw_EntryInfoFlags;
  94.         if (!BuildPrintStrings(CurrentWin)) {
  95.             CloseBrowserWindow(CurrentWin);
  96.             return;
  97.         }
  98.         Refresh = TRUE;
  99.     }
  100.     if (Refresh)
  101.         RefreshWindow(CurrentWin);
  102. }
  103.  
  104.  
  105. /* Affect window settings to all windows */
  106.  
  107. static void AffectAll(void)
  108. {
  109.     struct BrowserWindow *Win;
  110.     BOOL NewFileInfo, NewSort, NewFilters;
  111.  
  112.     Win = (struct BrowserWindow *)WindowList.mlh_Head;
  113.     while(Win->bw_Node.mln_Succ) {
  114.         NewFileInfo = NewSort = NewFilters = FALSE;
  115.         /* FileInfos */
  116.         if (Win->bw_EntryInfoFlags != CurrentWin->bw_EntryInfoFlags) {
  117.             Win->bw_EntryInfoFlags = CurrentWin->bw_EntryInfoFlags;
  118.             NewFileInfo = TRUE;
  119.         }
  120.         /* Sort */
  121.         if (Win->bw_Sort != CurrentWin->bw_Sort) {
  122.             Win->bw_Sort = CurrentWin->bw_Sort;
  123.             NewSort = TRUE;
  124.         }
  125.         /* Filters */
  126.         if (Win->bw_FiltersInfo != CurrentWin->bw_FiltersInfo) {
  127.             Win->bw_FiltersInfo = CurrentWin->bw_FiltersInfo;
  128.             /* List2Array() also does Sort() and BuildPrintStrings() */
  129.             NewFileInfo = FALSE;
  130.             NewSort = FALSE;
  131.             NewFilters = TRUE;
  132.         }
  133.         if (Win->bw_Type != BW_MAIN && (NewFileInfo | NewSort | NewFilters)) {
  134.             if (NewFilters) {
  135.                 if (List2Array(Win))
  136.                     MakeBottomInfoString(Win);
  137.                 else {
  138.                     CloseBrowserWindow(Win);
  139.                     return;
  140.                 }
  141.             }
  142.             if (NewFileInfo && !BuildPrintStrings(Win)) {
  143.                 CloseBrowserWindow(Win);
  144.                 return;
  145.             }
  146.             if (NewSort)
  147.                 Sort(Win);
  148.             RefreshWindow(Win);
  149.         }
  150.         Win = (struct BrowserWindow *)Win->bw_Node.mln_Succ;
  151.     }
  152. }
  153.  
  154.  
  155. static void Filters(short sub)
  156. {
  157.     struct SelectInfo *FI;
  158.     BOOL Refresh = FALSE;
  159.  
  160.     SetWaitPointer(TRUE);
  161.     FI = &CurrentWin->bw_FiltersInfo;
  162.     switch(sub) {
  163.     case 0:        /* Set... */
  164.         if (FiltersReq(FI ,FILTERS_REQ))
  165.             Refresh = TRUE;
  166.         break;
  167.     case 1:        /* Prefs */
  168.         CopyMem(&Config.DefaultFilters, FI, sizeof(struct SelectInfo));
  169.         Refresh = TRUE;
  170.         break;
  171.     case 2:        /* No .info */
  172.         if (FI->si_Flags & SI_INVERT) {
  173.             FI->si_Flags &= ~SI_INVERT;
  174.             Refresh = TRUE;
  175.         }
  176.         if (Strcmp(FI->si_Pattern, "~*.info")) {
  177.             strcpy(FI->si_Pattern, "~*.info");
  178.             PreParse("~*.INFO", FI->si_PatTok);
  179.             FI->si_Flags = (FI->si_Flags | (SI_NAME|SI_MATCH_FILES)) & ~SI_ALL_FILES;
  180.             Refresh = TRUE;
  181.         }
  182.         break;
  183.     case 3:        /* Clear */
  184.         if (FI->si_Flags != (SI_ALL_FILES|SI_ALL_DIRS)) {
  185.             setmem(FI, sizeof(struct SelectInfo), 0);
  186.             FI->si_Flags = SI_ALL_FILES|SI_ALL_DIRS;
  187.             Refresh = TRUE;
  188.         }
  189.         break;
  190.     case 4:        /* Invert */
  191.         FI->si_Flags ^= SI_INVERT;
  192.         Refresh = TRUE;
  193.         break;
  194.     }
  195.     if (Refresh && CurrentWin->bw_Type == BW_DIR) {
  196.         if (List2Array(CurrentWin)) {
  197.             MakeBottomInfoString(CurrentWin);
  198.             RefreshWindow(CurrentWin);
  199.         }
  200.         else
  201.             CloseBrowserWindow(CurrentWin);
  202.     }
  203.     SetWaitPointer(FALSE);
  204. }
  205.  
  206.  
  207. /* Atcho, bonsoir...  */
  208.  
  209. void exit(int);
  210.  
  211. static void Bye(short err)
  212. {
  213.     if (NumProcess > 0) {
  214.         SimpleRequest(ReqTitle, "Processes still running.");
  215.         return;
  216.     }
  217.     switch(err) {
  218.     case 0x001F:    /* SUBNUM() when no submenu */
  219.         err = 0;
  220.     case THE_END:
  221.     case NO_DEVS:
  222.         MainProcess->pr_WindowPtr = OldWindowPtr;
  223.         while(WindowList.mlh_Head->mln_Succ)
  224.             CloseBrowserWindow((struct BrowserWindow *)WindowList.mlh_TailPred);
  225.         if (CustomScreen)
  226.             CloseScreen(Screen);
  227.         FreeMenus(&ParMConfig);
  228.     case NO_WIN:
  229.         DeletePort(ProcessPort);
  230.     case NO_PROCESSPORT:
  231.         DeletePort(MainPort);
  232.     case NO_MAINPORT:
  233.         ;
  234.     }
  235.  
  236. #ifdef TRACKER
  237.     freeall();
  238. #endif
  239.  
  240.     exit(err);
  241. }
  242.  
  243.  
  244. void Rescan(void)
  245. {
  246.     if (CurrentWin->bw_Type == BW_MAIN) {
  247.         if (!ScanDevs())
  248.             Bye(NO_DEVS);
  249.     }
  250.     else if (!ScanDir(CurrentWin))
  251.         CloseBrowserWindow(CurrentWin);
  252. }
  253.  
  254.  
  255. void main(int argc, char *argv[])
  256. {
  257.     struct IntuiMessage *IMsg;
  258.     struct BrowserMsg *BMsg;
  259.     struct TaskData *TaskData;
  260.     ULONG WaitMask, Class;
  261.     USHORT Code,Qual;
  262.     SHORT X,Y;
  263.     ULONG Sec, Mic;
  264.     struct BrowserWindow *Win;
  265.     BPTR RootLock, fh;
  266.     void (*DoMenu)(short);
  267.  
  268. #ifdef TRACKER
  269.     if (!inittrack())
  270.         exit(0);
  271.     fh = NULL;    /* prevent 'variable not used' compile warning */
  272. #endif
  273.  
  274.     /* give a TaskData even to main process for actions in syncronous mode */
  275.     TaskData = ArpAlloc(sizeof(struct TaskData));
  276.     TaskData->td_InitialDir = BrowserDir;
  277.     MainProcess->pr_Task.tc_UserData = (APTR)TaskData;
  278.     if (!(MainPort = CreatePort(0,0)))
  279.         Bye(NO_MAINPORT);
  280.     if (!(ProcessPort = CreatePort(0,0)))
  281.         Bye(NO_PROCESSPORT);
  282.     WaitMask = (1L << MainPort->mp_SigBit) | (1L << ProcessPort->mp_SigBit);
  283.     NewMinList(&WindowList);    
  284.     InitDefaults(&ParMConfig);
  285.     ParMConfig.ReqTitle = ReqTitle;
  286.     ParMConfig.ItemHeight = 9;
  287.     strcpy(ParMConfig.CurCfg, BROWSERII_MENU_FILE);
  288.     LoadConfig();    /* Load config file ! */
  289.     InitMenus();    /* Init checkmarks for global "BrowserII" menu */
  290.     if (!OpenBrowserWindow(NULL, NULL, NULL, 0))        /* Open main window */
  291.         Bye(NO_WIN);
  292.     /* Make requesters appear in browser screen */
  293.     OldWindowPtr = MainProcess->pr_WindowPtr;
  294.  
  295. #ifndef TRACKER
  296.     MainProcess->pr_WindowPtr = (APTR)-1;    /* Prevent request if NULL: is not mounted */
  297.     if ((fh = Open("NULL:", MODE_NEWFILE)) || (fh = Open("NIL:", MODE_NEWFILE))) {
  298.         MainProcess->pr_CIS = fh;
  299.         MainProcess->pr_COS = fh;
  300.         MainProcess->pr_ConsoleTask = (APTR)((struct FileHandle *)(fh<<2))->fh_Type;
  301.     }
  302. #endif
  303.  
  304.     MainProcess->pr_WindowPtr = (APTR)CurrentWin->bw_Window;
  305.     ParMConfig.Win = CurrentWin->bw_Window;    /* Just for BlockPen check in menu alloc */
  306.     if (!ScanDevs())
  307.         Bye(NO_DEVS);
  308.     UpdateMenus();
  309.     SetTaskPri((struct Task *)MainProcess, 1);
  310.  
  311.     /* Monitor Menu Events */
  312.  
  313.     for(;;) {
  314.         Wait(WaitMask);
  315.         while (BMsg = (struct BrowserMsg *)GetMsg(ProcessPort)) {
  316.             switch(BMsg->bm_Type) {
  317.             case BM_STARTUP:    /* Reply. End of process */
  318.                 NumProcess--;
  319.                 FreeBrowserMsg(BMsg);
  320.                 break;
  321.             case BM_ACTIONBACK:
  322.                 DoActionBack(&BMsg->bm_Info.ActionBack.sfi, BMsg->bm_Info.ActionBack.SrcDir, BMsg->bm_Info.ActionBack.DestDir);
  323.                 ReplyMsg((struct Message *)BMsg);
  324.                 break;
  325.             case BM_UPDATEDIR:
  326.                 DoUpdateDir(BMsg->bm_Info.Dir);
  327.                 ReplyMsg((struct Message *)BMsg);
  328.                 break;
  329.             }
  330.         }
  331.         FreeRepliedWBMessages();
  332.         while (IMsg = (struct IntuiMessage *)GetMsg(MainPort)) {
  333.             Class = IMsg->Class;
  334.             Code = IMsg->Code;
  335.             Qual = IMsg->Qualifier;
  336.             /* Use raw keys to prevent ALT and CTRL convertions. Allow only Shift qualifiers */
  337.             if (Class == RAWKEY) {
  338.                 Code = RawKeyToAscii(Code, Qual & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT), IMsg->IAddress);
  339.                 if (Code != 0 && (Qual & ParMConfig.ShortCutQual) && !(Qual & IEQUALIFIER_REPEAT)) {
  340.                     Code = MakeMenuShortCut(&Menu1, Code);
  341.                     Class = MENUPICK;
  342.                 }
  343.             }
  344.             if (Class != DISKINSERTED && Class != DISKREMOVED && IMsg->IDCMPWindow != CurrentWin->bw_Window) {
  345.                 CurrentWin = FindWindow(IMsg->IDCMPWindow);
  346.                 SetMenus(CurrentWin);
  347.                 MakeMainBottomInfoString();
  348.             }
  349.             X = IMsg->MouseX;
  350.             Y = IMsg->MouseY;
  351.             Sec = IMsg->Seconds;
  352.             Mic = IMsg->Micros;
  353.             ReplyMsg((struct Message *)IMsg);
  354.             switch(Class) {
  355.             case MOUSEBUTTONS:
  356.                 switch(Code) {
  357.                 case SELECTDOWN:
  358.                     DoSelectDown(X, Y, Sec, Mic, Qual);
  359.                     break;
  360.                 case SELECTUP:
  361.                     DoSelectUp(X, Y);
  362.                     break;
  363.                 }
  364.                 break;
  365.             case NEWSIZE:
  366.                 RefreshWindow(CurrentWin);
  367.                 break;
  368.             case GADGETDOWN:
  369.                 RealTimeScroll(&CurrentWin->bw_ScrollStruct);
  370.                 break;
  371.             case GADGETUP:
  372.                 break;        /* Nothing yet ! */
  373.             case MENUPICK:
  374.                 DoNextSelect = TRUE;
  375.                 if (Code != MENUNULL) {
  376.                     do {
  377.                         switch(MENUNUM(Code)) {
  378.                         case 0:
  379.                         case 1:
  380.                             DoMenu = (MenuFunct[MENUNUM(Code)])[ITEMNUM(Code)];
  381.                             if (DoMenu) DoMenu(SUBNUM(Code));
  382.                             break;
  383.                         case 2:
  384.                             RunAction(NULL, ITEMNUM(Code));
  385.                             break;
  386.                         default:
  387.                             DoNextSelect = DoExtMenu(Code);
  388.                             if (!(Config.Options & OPT_KEEPSELECTED))
  389.                                 DeselectAll(NULL);
  390.                         }
  391.                     } while (DoNextSelect && (Code = ItemAddress(&Menu1, Code)->NextSelect) != MENUNULL);
  392.                     CheckMenus();
  393.                 }
  394.                 break;
  395.             case DISKINSERTED:
  396.             case DISKREMOVED:
  397.                 if (!ScanDevs())
  398.                     Bye(NO_DEVS);
  399.                 break;
  400.             case CLOSEWINDOW:
  401.                 RootLock = DupLock(CurrentWin->bw_RootLock);
  402.                 CloseBrowserWindow(CurrentWin);
  403.                 if (Qual & (IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)) {
  404.                     Win = (struct BrowserWindow *)WindowList.mlh_Head->mln_Succ;
  405.                     while(Win->bw_Node.mln_Succ) {
  406.                         if (!CompareLock(Win->bw_RootLock, RootLock)) {
  407.                             CloseBrowserWindow(Win);
  408.                             Win = (struct BrowserWindow *)WindowList.mlh_Head->mln_Succ;
  409.                         }
  410.                         else
  411.                             Win = (struct BrowserWindow *)Win->bw_Node.mln_Succ;
  412.                     }
  413.                 }
  414.                 UnLock(RootLock);
  415.                 break;
  416.             }
  417.         }
  418.     }
  419. }
  420.  
  421.  
  422.