home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / dirs / fileio_393.lzh / FileIO / C_Example / Main.c < prev    next >
C/C++ Source or Header  |  1990-10-28  |  9KB  |  346 lines
  1. #include <functions.h>
  2. #include <exec/types.h>
  3. #include <exec/io.h>
  4. #include <stdio.h>
  5. #include <exec/memory.h>
  6. #include <intuition/intuition.h>
  7. #include <intuition/intuitionbase.h>
  8. #include <graphics/gfxbase.h>
  9. #include "FileIO.h"
  10.  
  11. /* extern long GetMsg(), OpenWindow(), IoErr(), OpenLibrary(); */
  12.  
  13. /* === System Global Variables ========================================== */
  14. struct IntuitionBase *IntuitionBase = 0L;
  15. struct GfxBase            *GfxBase  = 0L;
  16. struct DosLibrary        *DosBase  = 0L;
  17. struct RequesterBase *RequesterBase = 0L;
  18. struct FileIO            *myFileIO  = 0L;
  19. struct FileIO            *myFileIO2 = 0L;
  20. struct Window            *myWindow  = 0L;
  21. struct Screen            *myScreen  = 0L;
  22. ULONG  argcount;  /* Saves argc from main(). argcount==0, then run from WB. */
  23.  
  24. struct TextAttr  topaz80_font;
  25.  
  26. BOOL TestFileIO();
  27.  
  28. struct NewScreen NewFileIOScreen =
  29.     {
  30.     0, 0,                 /* LeftEdge, TopEdge */
  31.     640, 400,         /* Width, Height */
  32.     2,                     /* Depth */
  33.     0, 1,                 /* Detail/BlockPens */
  34.     HIRES | LACE,     /* ViewPort Modes (must set/clear HIRES as needed) */
  35.     CUSTOMSCREEN,
  36.     &topaz80_font,  /* Font */
  37.     (UBYTE *)"Example FileIO Program's Screen",
  38.     0L,                 /* Gadgets */
  39.     0L,                 /* CustomBitMap */
  40.     };
  41.  
  42. struct NewWindow NewFileIOWindow =
  43.     {
  44.     168, 30,                  /* LeftEdge, TopEdge */
  45.     303, 145,             /* Width, Height */
  46.     -1, -1,                 /* Detail/BlockPens */
  47.     MENUPICK | MOUSEBUTTONS | CLOSEWINDOW | RAWKEY | DISKINSERTED,
  48.                              /* IDCMP Flags */
  49.     WINDOWDRAG | WINDOWDEPTH | SIZEBRIGHT | SMART_REFRESH |
  50.     WINDOWCLOSE | ACTIVATE | NOCAREREFRESH,
  51.                              /* Window Specification Flags */
  52.     0L,                     /* FirstGadget */
  53.     0L,                     /* Checkmark */
  54.     (UBYTE *)"FileIO Requester Window",  /* WindowTitle */
  55.     0L,                     /* Screen */
  56.     0L,                     /* SuperBitMap */
  57.     303, 145,             /* MinWidth, MinHeight */
  58.     600, 200,             /* MaxWidth, MaxHeight */
  59.     WBENCHSCREEN,
  60.     };
  61.  
  62.  
  63. struct IntuiText itxt[] = { 
  64.   {0,1,JAM1,19,1,NULL,(UBYTE *)"Multiple"},
  65.   {0,1,JAM1,19,1,NULL,(UBYTE *)"Handler"}, };
  66.  
  67. struct MenuItem mi[] = {
  68.   {&mi[1],0, 0,91,10,CHECKIT | MENUTOGGLE | ITEMTEXT | ITEMENABLED | HIGHCOMP,\
  69.     NULL,(APTR)&itxt[0],NULL,NULL},
  70.  
  71.   {NULL,0, 10,91,10,CHECKIT | MENUTOGGLE | ITEMTEXT | ITEMENABLED | HIGHCOMP,\
  72.     NULL,(APTR)&itxt[1],NULL,NULL},};
  73.  
  74. struct Menu myMenu = {NULL,0,0,72,0,MENUENABLED,  "Project",&mi[0]};
  75.  
  76.  
  77. BOOL myFunc();
  78.  
  79.  
  80. struct HandlerBlock hblock = {
  81.     /* APTR  StartUpCode; */         (APTR)myFunc,
  82.     /* APTR  DiskInsertedCode; */  0, 
  83.     /* APTR  GadgetCode; */             0, 
  84.     /* APTR  KeyCode; */                 0,
  85.     /* APTR  MouseMoveCode; */         0 };
  86.  
  87.  
  88.  
  89. /************************ MAIN ROUTINE *****************************/
  90.  
  91. VOID main(argc, argv)
  92. LONG argc;
  93. char **argv;
  94. {
  95.     LONG     class;
  96.     USHORT code;
  97.     struct IntuiMessage *message;
  98.     BOOL     end;
  99.  
  100.     argcount = argc;
  101.  
  102.     if (!(IntuitionBase = (struct IntuitionBase *)
  103.         OpenLibrary("intuition.library", 0L)))
  104.         exit_program("FileIO Demo: No intuition library. \n", 1L);
  105.  
  106.     if (!(GfxBase = (struct GfxBase *) OpenLibrary("graphics.library", 0L)))
  107.         exit_program("FileIO Demo: No graphics library. \n", 2L);
  108.  
  109.     /* NOW OPEN THE REQUESTER LIBRARY */
  110.  
  111.     if (!(RequesterBase = (struct RequesterBase *)OpenLibrary("requester.library", 1L)))
  112.         exit_program("FileIO Demo: No requester.library. \n", 4L);
  113.  
  114.     if (argv)
  115.         {
  116.         /* OK, we started from CLI */
  117.         if (argc > 1)
  118.             {
  119.  
  120. /*
  121.    Note: if we expected to receive a path name from the user as one of the
  122.    argv arguments, we should call requester lib's ParseString() now, passing
  123.    that arg. For example, assume that the user typed at the CLI:
  124.  
  125. TestProgram  df0:mydir/blort
  126.  
  127.    where df0:mydir/blort is some data file that TestProgram should load. We
  128.    would now call:
  129.  
  130.    ParseString(myFileIO, argv[1]);
  131.  
  132.    This will not only copy "df0:" to the FileIO's Diskname[], "mydir" to the
  133.    Drawername[], and "blort" to the Filename[], it will also set the FREEBYTES
  134.    and FILESIZE fields so that you know how much room is on the disk and whether
  135.    the file exists (FileIO->FileSize != 0). So, you can use the same load
  136.    routine that you would use for loading a data file after calling DoFileIO().
  137.    In fact, ParseString() is the routine to use if you want to set the FileIO
  138.    to some specific path without calling DoFileIO and presenting the req to the
  139.    user.
  140. */
  141.  
  142.             if (myScreen = OpenScreen(&NewFileIOScreen))
  143.                 {
  144.                 NewFileIOWindow.Screen = myScreen;
  145.                 NewFileIOWindow.Type = CUSTOMSCREEN;
  146.                 }
  147.             }
  148.         }
  149.  
  150.     if (!(myWindow = (struct Window *) OpenWindow( &NewFileIOWindow ) ))
  151.         exit_program("FileIO Demo: Null Window.\n", 5L);
  152.  
  153.  
  154.     SetMenuStrip( myWindow, &myMenu );
  155.  
  156.  /* GET 2 FileIO STRUCTURES */
  157.  
  158.     if (!(myFileIO = GetFileIO() ))
  159.         exit_program("FileIO Demo: No FileIO 1.\n", 6L);
  160.  
  161.     if (!(myFileIO2 = GetFileIO() ))
  162.         exit_program("FileIO Demo: No FileIO 2.\n", 7L);
  163.  
  164.   /* Set up the XY co-ordinates where the requester should open */
  165.  
  166.   myFileIO->X = 6;
  167.   myFileIO->Y = 11;
  168.  
  169.   myFileIO2->X = 6;
  170.   myFileIO2->Y = 11;
  171.  
  172.  /* Set default colors and DrawMode */
  173.   myFileIO->DrawMode = JAM2;
  174.   myFileIO->PenA = 1;
  175.   myFileIO->PenB = 0;
  176.   myFileIO2->DrawMode = JAM2;
  177.   myFileIO2->PenA = 1;
  178.   myFileIO2->PenB = 0;
  179.  
  180.              /* pretty easy to set up, eh?  */
  181.  
  182.     end = FALSE;
  183.  
  184.     SetFlag(myFileIO2->Flags, WBENCH_MATCH | MATCH_OBJECTTYPE);
  185.     myFileIO2->MatchType = WBTOOL;
  186.     SetFlag(myFileIO2->Flags, USE_DEVICE_NAMES);
  187.  
  188.     myFileIO->Custom = &hblock;
  189.     SetFileIOHandlers( &hblock );
  190.  
  191.     while (end == FALSE)
  192.      {
  193.         WaitPort(myWindow->UserPort);
  194.  
  195.         while (message = ( struct IntuiMessage *)GetMsg(myWindow->UserPort))
  196.          {
  197.             code = message->Code;
  198.             class = message->Class;
  199.             ReplyMsg(message);
  200.  
  201.             switch (class)
  202.              {
  203.                 case CLOSEWINDOW:
  204.                     end = TRUE;
  205.                     break;
  206.  
  207.                 case DISKINSERTED:
  208.                     /* You should clear the NO_CARE_REDRAW flag whenever you
  209.                      * detect that a new disk was inserted (if using this feature).
  210.                         We aren't using it, so comment it out.
  211.                     ClearFlag(myFileIO->Flags, NO_CARE_REDRAW);
  212.                     ClearFlag(myFileIO2->Flags, NO_CARE_REDRAW);
  213.                      */
  214.                     break;
  215.  
  216.                 case MENUPICK:
  217.                     switch( ITEMNUM( code ) )
  218.                     {
  219.                         case 0: 
  220.                             ToggleFlag( myFileIO->Flags, MULTIPLE_FILES );
  221.                             if (TestFileIO(myFileIO, myWindow))
  222.                             {
  223.                                 /*
  224.                                 ClearFlag(myFileIO->Flags, NO_CARE_REDRAW);
  225.                                 ClearFlag(myFileIO2->Flags, NO_CARE_REDRAW);
  226.                                 */
  227.                             }
  228.                             break;
  229.  
  230.                         case 1: 
  231.                             ToggleFlag( myFileIO->Flags, CUSTOM_HANDLERS );
  232.                             if (TestFileIO(myFileIO, myWindow))
  233.                             {
  234.                                 /*
  235.                                 ClearFlag(myFileIO->Flags, NO_CARE_REDRAW);
  236.                                 ClearFlag(myFileIO2->Flags, NO_CARE_REDRAW);
  237.                                 */
  238.                             }
  239.                             break;
  240.                     }  
  241.                     break;
  242.  
  243.                 case MOUSEBUTTONS:
  244.                     if (TestFileIO(myFileIO, myWindow))
  245.                     {
  246.                         /*
  247.                         ClearFlag(myFileIO->Flags, NO_CARE_REDRAW);
  248.                         ClearFlag(myFileIO2->Flags, NO_CARE_REDRAW);
  249.                         */
  250.                     }
  251.                     break;
  252.  
  253.                 case RAWKEY:
  254.                     if (TestFileIO(myFileIO2, myWindow))
  255.                     {
  256.                         /*
  257.                         ClearFlag(myFileIO->Flags, NO_CARE_REDRAW);
  258.                         ClearFlag(myFileIO2->Flags, NO_CARE_REDRAW);
  259.                         */
  260.                     }
  261.                     break;
  262.  
  263.                 default:
  264.                     break;
  265.              }
  266.          }
  267.      }
  268.   exit_program( 0L, 0L);
  269. }
  270.  
  271.  
  272.  
  273. exit_program( error_words, error_code )        /* All exits through here. */
  274. char  error_words;
  275. ULONG error_code;
  276. {
  277.     if( argcount && error_words ) puts( error_words );
  278.     if (myFileIO)  ReleaseFileIO(myFileIO);
  279.     if (myFileIO2) ReleaseFileIO(myFileIO2);
  280.  
  281.     if (myWindow) CloseWindow(myWindow);
  282.     if (myScreen) CloseScreen(myScreen);
  283.  
  284.     if (IntuitionBase) CloseLibrary(IntuitionBase);
  285.     if (GfxBase)         CloseLibrary(GfxBase);
  286.     if (DosBase)         CloseLibrary(DosBase);
  287.     if (RequesterBase) CloseLibrary(RequesterBase);
  288.     exit( error_code );
  289. }
  290.  
  291.  
  292.  
  293. BOOL TestFileIO(fileio, wind)
  294. struct FileIO *fileio;
  295. struct Window *wind;
  296. {
  297.  UBYTE *address;
  298.  struct FileEntry *fentry1 = 0, *fentry2 = 0;
  299.  
  300. /* This guy calls DoFileIO(), displays the file name selected by the
  301.  * user, and returns TRUE if the user swapped disks during DoFileIO()
  302.  * (else returns FALSE) if an error, CANCEL, or no disk swap.
  303.  */
  304.     UBYTE buffer[80];
  305.  
  306.     fileio->Buffer = buffer;
  307.  
  308.     address = DoFileIO(fileio, wind);
  309.  
  310.     if( address == buffer )
  311.     {
  312.         /* If user was positive and no error, display the name */
  313.         AutoMessage( buffer, wind);
  314.         if( fileio->Flags & MULTIPLE_FILES )
  315.         {
  316.             while( fentry2 = RetrieveEntry( &fentry1, fileio ) )
  317.             {
  318.                 AutoMessage( fentry2->filePart->EntryString, wind );
  319.             }
  320.         }
  321.     }
  322.  
  323.     if (!address)      AutoMessage("Error in operation", wind);
  324.     if (address==-1) AutoMessage("Cancelled operation", wind);
  325.  
  326.     if (FlagIsSet(fileio->Flags, DISK_HAS_CHANGED))
  327.         {
  328.         ClearFlag(fileio->Flags, DISK_HAS_CHANGED);
  329.         return(TRUE);
  330.         }
  331.     else
  332.       return(FALSE);
  333. }
  334.  
  335.  
  336. BOOL myFunc( extra,seconds,micros,mouseX,mouseY,fileio,xwind,iaddress )
  337. ULONG extra;
  338. APTR iaddress;
  339. struct Window *xwind;
  340. struct FileIO *fileio;
  341. SHORT mouseY, mouseX;
  342. ULONG micros,seconds;
  343. {
  344.      return(AutoPrompt3( "This is a custom StartHandler",0,0, xwind ));
  345. }
  346.