home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 1 / GoldFishApril1994_CD1.img / d1xx / d111 / amyload / init.c < prev    next >
C/C++ Source or Header  |  1987-11-15  |  6KB  |  272 lines
  1. #include    <intuition/intuition.h>
  2. #include    <devices/load.h>
  3. #include    "execdef.h"
  4. #include    "intuidef.h"
  5. #include    "error.h"
  6. #include    "windownode.h"
  7. #include    "windowinfo.h"
  8. #include    "loadrecord.h"
  9.  
  10. #include    "Init.proto"
  11.  
  12. #include    <exec/proto.h>
  13.  
  14. #include    "OpenLoadWindow.proto"
  15. #include    "NewLoadRecord.proto"
  16.  
  17. #define LINEWIDTH   1
  18. #define DEFAULT_LEFTEDGE    screenWidth-DEFAULT_WIDTH
  19. #define DEFAULT_TOPEDGE     10
  20. #define DEFAULT_WIDTH        100
  21. #define DEFAULT_HEIGHT        100
  22. #define MINWIDTH    BORDERWIDTH * 2 + LINEWIDTH
  23. #define MINHEIGHT   BORDERHEIGHT * 2 + LINEWIDTH
  24. #define MAXWIDTH    -1
  25. #define MAXHEIGHT   -1
  26. #define DEFAULT_DETAIL_PEN   -1
  27. #define DEFAULT_BLOCK_PEN    -1
  28. #define DEFAULT_DATA_PEN 1
  29. #define DEFAULT_REF_PEN  1
  30. #define DEFAULT_BACK_PEN 0
  31.  
  32. static NewWindow newWindow =
  33. { 0, 0, 0, 0,
  34.   0, 0,
  35.   0,
  36.   WINDOWSIZING | WINDOWDEPTH | WINDOWCLOSE | WINDOWDRAG | SIMPLE_REFRESH | RMBTRAP,
  37.   0, 0, 0, 0, 0,
  38.   MINWIDTH, MINHEIGHT, MAXWIDTH, MAXHEIGHT,
  39.   WBENCHSCREEN
  40. };
  41.  
  42. extern Library *GfxBase;
  43. extern struct IntuitionBase *IntuitionBase;
  44. extern MinList windowList;
  45. extern MsgPort *loadPort;
  46. extern MsgPort *windowPort;
  47. extern loadrequest *loadRequest;
  48.  
  49. static short atoi(char **);
  50. static void GetScreenDimensions();
  51. static void ParseGeometry(char **);
  52.  
  53. long   maxTicks;
  54. long   maxChip;
  55. long   maxFast;
  56. long   maxMem;
  57.  
  58. static char *default_argstr = "{[d3]}";
  59. static short screenWidth, screenHeight;
  60.  
  61. long
  62. Init(argstr)
  63.     char *argstr;
  64. {
  65.     WindowNode *node;
  66.     struct LoadBase *load_base;
  67.     Bool getting_record, getting_window;
  68.     short try_again;
  69.     unsigned char data_pen_num, ref_pen_num, back_pen_num, record_type;
  70.     char c;
  71.     struct Screen screen;
  72.  
  73.     if (!(GfxBase = OpenLibrary("graphics.library", 0)))
  74.     return ENOGFX;
  75.     if (!(IntuitionBase = (struct IntuitionBase *)OpenLibrary("intuition.library",0)))
  76.     return ENOINTUITION;
  77.     if (!(windowPort = CreatePort(0,0)))
  78.     return ENOPORT;
  79.     NewList(&windowList);
  80.     if (!(loadPort = CreatePort(0,0)))
  81.     return ENOPORT;
  82.     if (!(loadRequest = (loadrequest *)CreateExtIO(loadPort, sizeof(loadrequest))))
  83.     return ENOIOREQUEST;
  84.     if (OpenDevice("load.device",0,(IORequest *)loadRequest,0))
  85.     return ENODEVICE;
  86.     load_base = (struct LoadBase *)loadRequest->lr_node.io_Device;
  87.     maxTicks = load_base->ld_ticks;
  88.     maxChip  = load_base->ld_max_chip;
  89.     maxFast  = load_base->ld_max_fast;
  90.     maxMem   = maxChip + maxFast;
  91.     GetScreenDimensions();
  92.     while ((c = *argstr) && (c != ' '))
  93.     argstr++;
  94.     node = NULL;
  95.     for (try_again = 2; try_again--;)
  96.     {
  97.     while ((c = *argstr++) && (c != '\n'))
  98.     {
  99.         switch(c)
  100.         {
  101.         case 'i':
  102.         loadRequest->lr_interval = atoi(&argstr);
  103.         break;
  104.         case 't':
  105.         loadRequest->lr_ticks = atoi(&argstr);
  106.         break;
  107.         case 'p':
  108.         loadRequest->lr_pri = atoi(&argstr);
  109.         break;
  110.         case '{':
  111.         node = NULL;
  112.         newWindow.LeftEdge = DEFAULT_LEFTEDGE;
  113.         newWindow.TopEdge = DEFAULT_TOPEDGE;
  114.         newWindow.Width = DEFAULT_WIDTH;
  115.         newWindow.Height = DEFAULT_HEIGHT;
  116.         newWindow.DetailPen = DEFAULT_DETAIL_PEN;
  117.         newWindow.BlockPen = DEFAULT_BLOCK_PEN;
  118.         back_pen_num = DEFAULT_BACK_PEN;
  119.         for (getting_window = TRUE; getting_window;)
  120.         {
  121.             c = *argstr++;
  122.             switch(c)
  123.             {
  124.             case '=':
  125.             ParseGeometry(&argstr);
  126.             break;
  127.             case 'd':
  128.             newWindow.DetailPen = atoi(&argstr);
  129.             break;
  130.             case 'b':
  131.             newWindow.BlockPen = atoi(&argstr);
  132.             break;
  133.             case 'g':
  134.             back_pen_num = atoi(&argstr);
  135.             break;
  136.             case '[':
  137.             if (!node && !(node = OpenLoadWindow(&newWindow, back_pen_num)))
  138.                 return ENOWINDOW;
  139.             record_type = CPU;
  140.             ref_pen_num = DEFAULT_REF_PEN;
  141.             data_pen_num = DEFAULT_DATA_PEN;
  142.             for (getting_record = TRUE; getting_record; )
  143.             {
  144.                 c = *argstr++;
  145.                 switch(c)
  146.                 {
  147.                 case 'C':
  148.                 record_type = CPU;
  149.                 break;
  150.                 case 'b':
  151.                 record_type = BLITTER;
  152.                 break;
  153.                 case 'm':
  154.                 record_type = ALLMEM;
  155.                 break;
  156.                 case 'c':
  157.                 record_type = CHIPMEM;
  158.                 break;
  159.                 case 'f':
  160.                 record_type = FASTMEM;
  161.                 break;
  162.                 case 'd':
  163.                 data_pen_num = atoi(&argstr);
  164.                 break;
  165.                 case 'r':
  166.                 ref_pen_num = atoi(&argstr);
  167.                 break;
  168.                 case ' ':
  169.                 break;
  170.                 case ']':
  171.                 getting_record = FALSE;
  172.                 break;
  173.                 case '\n':
  174.                 case '\0':
  175.                 /* Error: Unexpected end of record. */
  176.                 return EUNXEOR;
  177.                 default:
  178.                 /* Error: Unknown record flag. */
  179.                 return EBADRFLAG;
  180.                 }
  181.             }
  182.             if (!(NewLoadRecord(WINDOWINFO(node->window), record_type, data_pen_num, ref_pen_num)))
  183.                 return ENORECORD;
  184.             break;
  185.             case ' ':
  186.             break;
  187.             case '}':
  188.             getting_window = FALSE;
  189.             break;
  190.             case '\n':
  191.             case '\0':
  192.             /* Error: Unexpected end of window. */
  193.             return EUNXEOW;
  194.             default:
  195.             /* Error: Unknown window flag. */
  196.             return EBADWFLAG;
  197.             }
  198.         }
  199.         break;
  200.         case ' ':
  201.         break;
  202.         default:
  203.         /* Error: Unknown global flag. */
  204.         return EBADGFLAG;
  205.         }
  206.     }
  207.     if (!node)
  208.         argstr = default_argstr;
  209.     else
  210.         break;
  211.     }
  212.     loadRequest->lr_node.io_Command = LD_SET;
  213.     DoIO(loadRequest);
  214.     return 0;
  215. }
  216.  
  217. static
  218. short atoi(s)
  219.     register char **s;
  220. {
  221.     register short num;
  222.  
  223.     for (num = 0; isdigit(**s); (*s)++)
  224.     num = num * (short)10 + **s - '0';
  225.     return num;
  226. }
  227.  
  228. static
  229. void
  230. GetScreenDimensions()
  231. {
  232.     struct Screen screen;
  233.  
  234.     GetScreenData(&screen,  sizeof(struct Screen), WBENCHSCREEN, NULL);
  235.     screenWidth = screen.Width;
  236.     screenHeight = screen.Height;
  237. }
  238.  
  239. static
  240. void
  241. ParseGeometry(string)
  242.     register char **string;
  243. {
  244.     register char c;
  245.  
  246.     c = **string;
  247.     if (c != 'x' && c != '+' && c != '-')
  248.     newWindow.Width = atoi(string);
  249.     c = *((*string)++);
  250.     if (c == 'x')
  251.     {
  252.     newWindow.Height = atoi(string);
  253.     c = *((*string)++);
  254.     }
  255.     if (c == '+')
  256.     {
  257.     newWindow.LeftEdge = atoi(string);
  258.     c = *((*string)++);
  259.     }
  260.     else if (c == '-')
  261.     {
  262.     newWindow.LeftEdge = screenWidth - atoi(string) - newWindow.Width;
  263.     c = *((*string)++);
  264.     }
  265.     else
  266.     return;
  267.     if (c == '+')
  268.     newWindow.TopEdge = atoi(string);
  269.     else if (c == '-')
  270.     newWindow.TopEdge = screenHeight - atoi(string) - newWindow.Height;
  271. }
  272.