home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / fish / libraries / fileio_463 / c / customlist.c next >
C/C++ Source or Header  |  1991-02-08  |  9KB  |  335 lines
  1. /*************************************************************************
  2.  This program opens and utilizes the requester.library in order to use
  3.  the new SPECIAL_REQ flag. This flag allows us to display a list of
  4.  strings in a requester with all the features of the FileIO requester.
  5.  Because version 0 of the library did not support this feature, but version
  6.  1.5 now does, we must open the library with version #1. Old applications
  7.  that do not know about SPECIAL_REQ will still work with this version of
  8.  the library. It is backward compatible as far as the disk IO features are
  9.  concerned.
  10.  
  11.  NOTE: Under version 1.B of the requester.library, custom strings are now
  12.  limited to 191 characters instead of 29.
  13.  
  14.  If running this program from the CLI and you specify any argument on the
  15.  command (i.e.  1> TestFileIO blort ), then the window will open on a hires
  16.  screen. You can then see what the requester looks like in hires.
  17.  
  18.  Manx compile:
  19.  cc +p CustomList.c
  20.  ln CustomList.o -lcl32
  21.  
  22. **************************************************************************/
  23.  
  24. #include <functions.h>
  25. #include <exec/types.h>
  26. #include <exec/io.h>
  27. #include <stdio.h>
  28. #include <exec/memory.h>
  29. #include <intuition/intuition.h>
  30. #include <intuition/intuitionbase.h>
  31. #include <graphics/gfxbase.h>
  32. #include "FileIO.h"
  33.  
  34. /* extern long GetMsg(), OpenWindow(), IoErr(), OpenLibrary(); */
  35.  
  36. /* === System Global Variables ========================================== */
  37. struct IntuitionBase *IntuitionBase = 0L;
  38. struct GfxBase            *GfxBase  = 0L;
  39. struct DosLibrary        *DosBase  = 0L;
  40. struct RequesterBase *RequesterBase = 0L;
  41. struct FileIO            *myFileIO  = 0L;
  42. struct Window            *myWindow  = 0L;
  43. struct Screen            *myScreen  = 0L;
  44. ULONG  argcount;  /* Saves argc from main(). argcount==0, then run from WB. */
  45.  
  46. struct TextAttr  topaz80_font;
  47.  
  48. VOID TestFileIO();
  49.  
  50. struct NewScreen NewFileIOScreen =
  51.     {
  52.     0, 0,                /* LeftEdge, TopEdge */
  53.     640, 400,        /* Width, Height */
  54.     2,                    /* Depth */
  55.     0, 1,                /* Detail/BlockPens */
  56.     HIRES | LACE,    /* ViewPort Modes (must set/clear HIRES as needed) */
  57.     CUSTOMSCREEN,
  58.     &topaz80_font, /* Font */
  59.     (UBYTE *)"Example FileIO Program's Screen",
  60.     0L,                /* Gadgets */
  61.     0L,                /* CustomBitMap */
  62.     };
  63.  
  64. struct NewWindow NewFileIOWindow =
  65.     {
  66.     168, 30,                 /* LeftEdge, TopEdge */
  67.     303, 145,            /* Width, Height */
  68.     -1, -1,                /* Detail/BlockPens */
  69.     MENUPICK | MOUSEBUTTONS | CLOSEWINDOW,
  70.                             /* IDCMP Flags */
  71.     WINDOWDRAG | WINDOWDEPTH | SIZEBRIGHT | SMART_REFRESH |
  72.     WINDOWCLOSE | ACTIVATE | NOCAREREFRESH,
  73.                             /* Window Specification Flags */
  74.     0L,                    /* FirstGadget */
  75.     0L,                    /* Checkmark */
  76.     (UBYTE *)"FileIO SPECIAL_REQ Example",  /* WindowTitle */
  77.     0L,                    /* Screen */
  78.     0L,                    /* SuperBitMap */
  79.     303, 145,            /* MinWidth, MinHeight */
  80.     600, 200,            /* MaxWidth, MaxHeight */
  81.     WBENCHSCREEN,
  82.     };
  83.  
  84. struct IntuiText itxt[] = { 
  85.   {0,1,JAM1,19,1,NULL,(UBYTE *)"Multiple"},
  86.   {0,1,JAM1,19,1,NULL,(UBYTE *)"Handler"}, };
  87.  
  88. struct MenuItem mi[] = {
  89.   {&mi[1],0, 0,91,10,CHECKIT | MENUTOGGLE | ITEMTEXT | ITEMENABLED | HIGHCOMP,\
  90.     NULL,(APTR)&itxt[0],NULL,NULL},
  91.  
  92.   {NULL,0, 10,91,10,CHECKIT | MENUTOGGLE | ITEMTEXT | ITEMENABLED | HIGHCOMP,\
  93.     NULL,(APTR)&itxt[1],NULL,NULL},};
  94.  
  95. struct Menu myMenu = {NULL,0,0,72,0,MENUENABLED,  "Project",&mi[0]};
  96.  
  97.  
  98. BOOL myFunc();
  99.  
  100.  
  101. struct HandlerBlock hblock = {
  102.     /* APTR  StartUpCode; */        (APTR)myFunc,
  103.     /* APTR  DiskInsertedCode; */ 0, 
  104.     /* APTR  GadgetCode; */            0, 
  105.     /* APTR  KeyCode; */                0,
  106.     /* APTR  MouseMoveCode; */        0 };
  107.  
  108. BOOL information();
  109.  
  110. UBYTE button_text[] = {"   About"};
  111.  
  112. /************************ MAIN ROUTINE *****************************/
  113.  
  114. VOID main(argc, argv)
  115. LONG argc;
  116. char **argv;
  117. {
  118.     LONG     class;
  119.     USHORT code;
  120.     struct IntuiMessage *message;
  121.     BOOL     end;
  122.  
  123.     argcount = argc;
  124.  
  125.     if (!(IntuitionBase = (struct IntuitionBase *)
  126.         OpenLibrary("intuition.library", 0L)))
  127.         exit_program("FileIO Demo: No intuition library. \n", 1L);
  128.  
  129.     if (!(GfxBase = (struct GfxBase *) OpenLibrary("graphics.library", 0L)))
  130.         exit_program("FileIO Demo: No graphics library. \n", 2L);
  131.  
  132.     /* NOW OPEN THE REQUESTER LIBRARY, Version 1 */
  133.  
  134.     if (!(RequesterBase = (struct RequesterBase *)OpenLibrary("requester.library", 1L)))
  135.         exit_program("FileIO Demo: No requester library. \n", 4L);
  136.  
  137.     if (argv)
  138.         {
  139.         /* OK, we started from CLI */
  140.         if (argc > 1)
  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.     if (!(myFileIO = GetFileIO() ))
  154.         exit_program("FileIO Demo: No FileIO 1.\n", 6L);
  155.  
  156.     /* Set up the XY co-ordinates where the requester should open */
  157.  
  158.     myFileIO->X = 6;
  159.     myFileIO->Y = 11;
  160.  
  161.     /* Set default colors and DrawMode */
  162.     myFileIO->DrawMode = JAM2;
  163.     myFileIO->PenA = 1;
  164.     myFileIO->PenB = 0;
  165.     myFileIO->FileIOText = button_text;
  166.     myFileIO->FileIORoutine = (APTR)information;  /* pointer to function */
  167.     SetFlag(myFileIO->Flags, SPECIAL_REQ );
  168.  
  169.             /* pretty easy to set up, eh?  */
  170.  
  171.     SetMenuStrip( myWindow, &myMenu );
  172.  
  173.     /* These 2 lines are to demo using the CUSTOM_HANDLERS */
  174.     myFileIO->Custom = &hblock;
  175.     SetFileIOHandlers( &hblock );
  176.  
  177.     end = FALSE;
  178.     while (end == FALSE)
  179.      {
  180.         WaitPort(myWindow->UserPort);
  181.  
  182.         while (message = ( struct IntuiMessage *)GetMsg(myWindow->UserPort))
  183.          {
  184.             class = message->Class;
  185.             code = message->Code;
  186.             ReplyMsg(message);
  187.  
  188.             switch (class)
  189.              {
  190.                 case CLOSEWINDOW:
  191.                     end = TRUE;
  192.                     break;
  193.  
  194.                 case MENUPICK:
  195.                     switch( ITEMNUM( code ) )
  196.                     {
  197.                         case 0: 
  198.                             ToggleFlag( myFileIO->Flags, MULTIPLE_FILES );
  199.                             TestFileIO(myFileIO, myWindow);
  200.                             break;
  201.  
  202.                         case 1: 
  203.                             ToggleFlag( myFileIO->Flags, CUSTOM_HANDLERS );
  204.                             TestFileIO(myFileIO, myWindow);
  205.                             break;
  206.                     }
  207.                     break;
  208.  
  209.                 case MOUSEBUTTONS:
  210.                     if( code == SELECTDOWN )
  211.                         TestFileIO(myFileIO, myWindow);
  212.                     break;
  213.  
  214.                 default:
  215.                     break;
  216.              }
  217.          }
  218.      }
  219.   exit_program( 0L, 0L);
  220. }
  221.  
  222.  
  223. exit_program( error_words, error_code )        /* All exits through here. */
  224. char * error_words;
  225. ULONG error_code;
  226. {
  227.     if( argcount && error_words ) puts( error_words );
  228.  
  229.     if (myWindow) CloseWindow(myWindow);
  230.     if (myScreen) CloseScreen(myScreen);
  231.  
  232.     if (IntuitionBase) CloseLibrary(IntuitionBase);
  233.     if (GfxBase)         CloseLibrary(GfxBase);
  234.     if (DosBase)         CloseLibrary(DosBase);
  235.     if (RequesterBase)
  236.     {
  237.         ReleaseFileIO(myFileIO);
  238.         CloseLibrary(RequesterBase);
  239.     }
  240.     exit( error_code );
  241. }
  242.  
  243.  
  244. UBYTE string[10][14] = {
  245.     {"This is One"},
  246.     {"This is Two"},
  247.     {"This is Three"},
  248.     {"This is Four"},
  249.     {"This is Five"},
  250.     {"This is Sex"},
  251.     {"This is Seven"},
  252.     {"This is Eight"},
  253.     {"This is Nine"},
  254.     {"This is Ten"},};
  255.  
  256.  
  257. VOID TestFileIO(fileio, wind)
  258. struct FileIO *fileio;
  259. struct Window *wind;
  260. {
  261.     struct FileEntry *fentry1 = 0, *fentry2 = 0;
  262.     UBYTE *address;
  263.     UBYTE c;
  264.     SHORT err;
  265.  
  266. /* This function makes the list of strings to display, and calls DoFileIO().
  267.     We have set the SPECIAL_REQ flag of FileIO. */
  268.  
  269.     NewEntryList( fileio );  /* frees any previous list */
  270.  
  271.     for( c=0; c<10; c++ )
  272.     {
  273.         err = AddEntry( c+1, string[c], fileio );
  274.         if( err < 0 )      AutoMessage("Out of memory for this string", wind );
  275.     }
  276.  
  277.     address = DoFileIO(fileio, wind);
  278.  
  279.     if( address == fileio->FileName )
  280.     {
  281.         /* If user was positive and no error, display the name */
  282.         fileio->FileName[75] = 0; /* Let's clip it to MAX 75 chars before display */
  283.         AutoMessage( fileio->FileName, wind);
  284.         if( fileio->FileSize == -1 )
  285.         {
  286.              /* If user typed in string not in the list, indicate this */
  287.              AutoMessage( "string not in the list", wind);
  288.         }
  289.         if( fileio->Errno == ERR_APPGADG )
  290.         {
  291.              AutoMessage( "Cancelled by custom routine.", wind);
  292.         }
  293.         if( fileio->Flags & MULTIPLE_FILES )
  294.         {
  295.             while( fentry2 = RetrieveEntry( &fentry1, fileio ) )
  296.             {
  297.                 AutoMessage( fentry2->filePart->EntryString, wind );
  298.             }
  299.         }
  300.     }
  301.  
  302.     if (!address)      AutoMessage("Error in operation", wind);
  303.     if (address==-1) AutoMessage("Cancelled operation", wind);
  304.     if (address==-2) AutoMessage("Library in use", wind);
  305.  
  306. }
  307.  
  308.  
  309. /*------- This is the for SPECIAL_REQ's "NextDisk" gadget replacement ------*/
  310. /* Returning a 1 ends the requester with ERR_APPGADG. A 0 just returns control
  311.     to the requester lib. Also note that we can change the FileIOText and
  312.     even FileIORoutine, which will be set accordingly when we return(0) */
  313.  
  314. BOOL information( req, wind, fileio )
  315. struct Requester *req;
  316. struct Window *wind;
  317. struct FileIO *fileio;
  318. {
  319.     return(AutoPrompt3("This is the extra gadget routine",0,0, wind ));
  320. }
  321.  
  322.  
  323. /* -------- This is the CUSTOM_HANDLERS StartHandler routine ---------- */
  324.  
  325. BOOL myFunc( extra,seconds,micros,mouseX,mouseY,fileio,xwind,iaddress )
  326. ULONG extra;
  327. APTR iaddress;
  328. struct Window *xwind;
  329. struct FileIO *fileio;
  330. SHORT mouseY, mouseX;
  331. ULONG micros,seconds;
  332. {
  333.     return(AutoPrompt3( "This is a custom StartHandler",0,0, xwind ));
  334. }
  335.