home *** CD-ROM | disk | FTP | other *** search
/ Fish 'n' More 2 / fishmore-publicdomainlibraryvol.ii1991xetec.iso / disks / disk447.lzh / DFC / Window.c < prev   
C/C++ Source or Header  |  1991-02-02  |  10KB  |  376 lines
  1. #include "DFC5.h"
  2.  
  3. char df0[] = "df0:" ;                  /* use only one copy of this name */
  4. char df1[] = "df1:" ;                  /* ditto */
  5. char df2[] = "df2:" ;                  /* ditto */
  6. char df3[] = "df3:" ;                  /* ditto */
  7. char *df[]={df0, df1, df2, df3};      /* for easy access to drive names */
  8.  
  9. /*
  10.  *      Always use topaz 80, and let's define an intuition buffer for our
  11.  *      general string writing stuff.
  12.  */
  13.  
  14. struct TextAttr Topaz8 = {(STRPTR)"topaz.font", TOPAZ_EIGHTY, 0, 0 };
  15. struct IntuiText IntuiText = {1, 0, JAM2, 0, 0, &Topaz8} ;
  16.  
  17. /*
  18.  * This is to ``get that look''...
  19.  */
  20.  
  21. SHORT XY1[6]={ 0,11,0,0,63,0 };
  22. SHORT XY2[6]={ 1,11,63,11,63,0 };
  23.  
  24. /*
  25.  * The copy progress bar 3D border.
  26.  */
  27.  
  28. SHORT BXY1[6]={ 0,9,321,9,321,0 };
  29. SHORT BXY2[6]={ 0,8,0,0,320,0 };
  30.  
  31. /*
  32.  * The first two items are the gadget border, the other two ones the progress
  33.  * bar border.
  34.  */
  35.  
  36. struct Border Border[] = {
  37.     {    0,0,2,0,JAM1,3,XY1,&Border[1]    },
  38.     {    0,0,1,0,JAM1,3,XY2,NULL },
  39.     {    0,0,2,0,JAM1,3,BXY1,&Border[3]    },
  40.     {    0,0,1,0,JAM1,3,BXY2,NULL    }
  41. };
  42.  
  43. /*
  44.  * ITexts for gadgets.
  45.  */
  46.  
  47. struct IntuiText IText[18] = {
  48.     {    1,0,JAM1, 17,2, &Topaz8, df0, NULL    },
  49.     {    1,0,JAM1, 17,2, &Topaz8, df1, NULL    },
  50.     {    1,0,JAM1, 17,2, &Topaz8, df2, NULL    },
  51.     {    1,0,JAM1, 17,2, &Topaz8, df3, NULL    },
  52.     {    1,0,JAM1, 17,2, &Topaz8, df0, NULL    },
  53.     {    1,0,JAM1, 17,2, &Topaz8, df1, NULL    },
  54.     {    1,0,JAM1, 17,2, &Topaz8, df2, NULL    },
  55.     {    1,0,JAM1, 17,2, &Topaz8, df3, NULL    },
  56.     {    1,0,JAM1, 8,2, &Topaz8, "Verify", NULL },
  57.     {    1,0,JAM1, 8,2, &Topaz8, "Buffer", NULL },
  58.     {    1,0,JAM1, 16,2, &Topaz8, "Talk", NULL    },
  59.     {    1,0,JAM1, 20,2, &Topaz8, "FFS", NULL    },
  60.     {    1,0,JAM1, 16,2, &Topaz8, "Date", NULL    },
  61.     {    1,0,JAM1, 16,2, &Topaz8, "Stop", NULL    },
  62.     {    1,0,JAM1, 24,2, &Topaz8, "Go", NULL },
  63.     {    1,0,JAM1, 8,2, &Topaz8, "Repeat", NULL },
  64.     {    1,0,JAM1, 8,2, &Topaz8, "Format", NULL },
  65.     {    1,0,JAM1, 16,2, &Topaz8, "Auto", NULL }
  66. };
  67.  
  68. /*
  69.  * The gadgets.
  70.  */
  71.  
  72. struct Gadget Gadget[18] = {
  73.     {    &Gadget[1], 80,20, 64,12,
  74.         GADGHCOMP, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  75.         (APTR)&Border[0], NULL, &IText[0], NULL, NULL, '0', NULL
  76.     },
  77.     {    &Gadget[2], 148,20, 64,12,
  78.         GADGHCOMP, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  79.         (APTR)&Border[0], NULL, &IText[1], NULL, NULL, '1', NULL
  80.     },
  81.     {    &Gadget[3], 216,20, 64,12,
  82.         GADGHCOMP, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  83.         (APTR)&Border[0], NULL, &IText[2], NULL, NULL, '2', NULL
  84.     },
  85.     {    &Gadget[4], 284,20, 64,12,
  86.         GADGHCOMP, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  87.         (APTR)&Border[0], NULL, &IText[3], NULL, NULL, '3', NULL
  88.     },
  89.     {    &Gadget[5], 80,50, 64,12,
  90.         GADGHCOMP, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  91.         (APTR)&Border[0], NULL, &IText[4], NULL, NULL, '4', NULL
  92.     },
  93.     {    &Gadget[6], 148,50, 64,12,
  94.         GADGHCOMP, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  95.         (APTR)&Border[0], NULL, &IText[5], NULL, NULL, '5', NULL
  96.     },
  97.     {    &Gadget[7], 216,50, 64,12,
  98.         GADGHCOMP, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  99.         (APTR)&Border[0], NULL, &IText[6], NULL, NULL, '6', NULL
  100.     },
  101.     {    &Gadget[8], 284,50, 64,12,
  102.         GADGHCOMP, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  103.         (APTR)&Border[0], NULL, &IText[7], NULL, NULL, '7', NULL
  104.     },
  105.     {    &Gadget[9], 12,65, 64,12,
  106.         GADGHCOMP| SELECTED, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  107.         (APTR)&Border[0], NULL, &IText[8], NULL, NULL, 'V', NULL
  108.     },
  109.     {    &Gadget[10], 80,65, 64,12,
  110.         GADGHCOMP, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  111.         (APTR)&Border[0], NULL, &IText[9], NULL, NULL, 'B', NULL
  112.     },
  113.     {    &Gadget[11], 148,65, 64,12,
  114.         GADGHCOMP, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  115.         (APTR)&Border[0], NULL, &IText[10], NULL, NULL, 'T', NULL
  116.     },
  117.     {    &Gadget[12], 216,65, 64,12,
  118.         GADGHCOMP, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  119.         (APTR)&Border[0], NULL, &IText[11], NULL, NULL, 'N', NULL
  120.     },
  121.     {    &Gadget[13], 284,65, 64,12,
  122.         GADGHCOMP| SELECTED, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  123.         (APTR)&Border[0], NULL, &IText[12], NULL, NULL, 'D', NULL
  124.     },
  125.     {    &Gadget[14], 12,80, 64,12,
  126.         GADGHCOMP, RELVERIFY, BOOLGADGET,
  127.         (APTR)&Border[0], NULL, &IText[13], NULL, NULL, 'S', NULL
  128.     },
  129.     {    &Gadget[15], 80,80, 64,12,
  130.         GADGHCOMP, RELVERIFY, BOOLGADGET,
  131.         (APTR)&Border[0], NULL, &IText[14], NULL, NULL, 'G', NULL
  132.     },
  133.     {    &Gadget[16], 148,80, 64,12,
  134.         GADGHCOMP, RELVERIFY, BOOLGADGET,
  135.         (APTR)&Border[0], NULL, &IText[15], NULL, NULL, 'R', NULL
  136.     },
  137.     {    &Gadget[17], 216,80, 64,12,
  138.         GADGHCOMP, RELVERIFY, BOOLGADGET,
  139.         (APTR)&Border[0], NULL, &IText[16], NULL, NULL, 'F', NULL
  140.     },
  141.     {    NULL, 284,80, 64,12,
  142.         GADGHCOMP | GADGDISABLED, GADGIMMEDIATE | TOGGLESELECT, BOOLGADGET,
  143.         (APTR)&Border[0], NULL, &IText[17], NULL, NULL, 'A', NULL
  144.     }
  145. };
  146.  
  147. struct NewWindow NewWindow = {
  148.     128,64, 360,100, 0,1,
  149.     GADGETDOWN | GADGETUP | CLOSEWINDOW | VANILLAKEY,
  150.     WINDOWDRAG | WINDOWDEPTH | WINDOWCLOSE | ACTIVATE | NOCAREREFRESH,
  151.     &Gadget[0], NULL, "DFC5--by T. Rokicki/S. Vigna", NULL, NULL, 360,100, -1,-1, WBENCHSCREEN
  152. };
  153.  
  154. /*
  155.  * This structures are for AutoRequest();
  156.  */
  157.  
  158. struct IntuiText Req = {
  159.     AUTOFRONTPEN, AUTOBACKPEN, AUTODRAWMODE,
  160.     20,20,
  161.     &Topaz8,
  162. };
  163.  
  164. struct IntuiText Cancel = {
  165.   AUTOFRONTPEN, AUTOBACKPEN, AUTODRAWMODE,
  166.   AUTOLEFTEDGE, AUTOTOPEDGE,
  167.     &Topaz8,
  168.   NULL,
  169.   AUTONEXTTEXT
  170. };
  171.  
  172. struct IntuiText Retry = {
  173.   AUTOFRONTPEN, AUTOBACKPEN, AUTODRAWMODE,
  174.   AUTOLEFTEDGE, AUTOTOPEDGE,
  175.     &Topaz8,
  176.   "Try Again",
  177.   AUTONEXTTEXT
  178. };
  179.  
  180.  
  181. /*
  182.  * Here we invert the border colors if we are under 1.3
  183.  */
  184.  
  185. void ReverseBorderColors(void) {
  186.  
  187.     int i;
  188.     for(i=0; i<4; i++) Border[i].FrontPen = i%2+1;
  189. }
  190.  
  191.  
  192. /*
  193.  * This is for read errors, write errors etc.
  194.  */
  195.  
  196. int ProblemsWithUnit(char *s, int Unit, int Track) {
  197.  
  198.     static char s2[100];
  199.  
  200.     sprintf(s2, "%s error on disk %ld, track %ld.", s, Unit, Track);
  201.     Req.IText = s2;
  202.     Say(s2);
  203.     Cancel.IText = "So What?";
  204.     return(AutoRequest(0, &Req, &Retry, &Cancel, 0, 0, 320, 72));
  205. }
  206.  
  207. /*
  208.  * This is only for saying something that's only a notification.
  209.  */
  210.  
  211. void Acknowledge(char *s) {
  212.  
  213.     Req.IText = s;
  214.     Say(s);
  215.     Cancel.IText = "OK";
  216.     AutoRequest(0, &Req, NULL, &Cancel, 0, 0, 320, 72);
  217. }
  218.  
  219.  
  220. /*
  221.  *      This routine draws a string into the window at
  222.  *      a specific X, Y location.
  223.  */
  224.  
  225. void DrawText(struct Window *Window, char *String, int x, int y) {
  226.  
  227.     IntuiText.IText = (UBYTE *)String ;
  228.     PrintIText(Window->RPort, &IntuiText, (long)x, (long)y) ;
  229. }
  230.  
  231. /*
  232.  *      This set of routines draw the progress bar. They're fairly smart---
  233.  *   first they update Bar, then they check for the layer we need being
  234.  *   unlocked. If it's not the case, they set SomethingFailed go.
  235.  *   As soon as the layer is free, the bar is redrawn basing on Bar.
  236.  *   This allows for smooth copy operations even if someone uses menus
  237.  *   (thus locking all layers). UpDateProgress forces the bar to be
  238.  *   updated.
  239.  */
  240.  
  241. static unsigned char SomethingFailed, Bar[20];
  242.  
  243. void PrintRectAt(struct Window *Window, int n, int color) {
  244.     SetDrMd(Window->RPort, JAM1);
  245.     SetAPen(Window->RPort, color);
  246.     RectFill(Window->RPort, 21+n*4, 37, (21+3)+n*4, 44);
  247. }
  248.  
  249. void UpdateProgress(struct Window *Window) {
  250.  
  251.     register int i;
  252.  
  253.     if (SomethingFailed) {
  254.         for(i=0; i<80; i++) PrintRectAt(Window, i, (Bar[i/4]>>(2*(i%4))) & 3);
  255.         SomethingFailed = 0;
  256.     }
  257. }
  258.  
  259. void DrawProgress(struct Window *Window, int n, int color) {
  260.  
  261.     Bar[n/4] &= ~(3<<(2*(n%4)));
  262.     Bar[n/4] |= color<<(2*(n%4));
  263.  
  264.     if (Window->WScreen->LayerInfo.Lock.ss_NestCount == 0) {
  265.         UpdateProgress(Window);
  266.         PrintRectAt(Window, n, color);
  267.     }
  268.     else SomethingFailed = 1;
  269. }
  270.  
  271. /*
  272.  *      This routine wipes the progress bar.
  273.  */
  274.  
  275. void WipeProgress(struct Window *Window, int start) {
  276.  
  277.     register int i;
  278.  
  279.     for(i=start; i<80; i++) DrawProgress(Window, i, 0);
  280. }
  281.  
  282.  
  283. /*
  284.  * This sets up the window.
  285.  */
  286.  
  287. struct Window *SetUpWindow(void) {
  288.  
  289.     register struct Window *Window;
  290.  
  291.     if (Window = OpenWindow(&NewWindow)) {
  292.  
  293.         DrawText(Window, "Source", 20, 22);
  294.         DrawText(Window, "Dest", 28, 52);
  295.         DrawBorder(Window->RPort, &Border[2], 20, 36);
  296.     }
  297.     return(Window);
  298. }
  299.  
  300. /*
  301.  * Here we wipe completely a gadget
  302.  */
  303.  
  304. void WipeGadget(struct Window *Window, struct Gadget *G) {
  305.  
  306.     SetAPen(Window->RPort, 0);
  307.     SetDrMd(Window->RPort, JAM1);
  308.     RectFill(Window->RPort, G->LeftEdge, G->TopEdge, G->LeftEdge+G->Width-1, G->TopEdge+G->Height-1);
  309. }
  310.  
  311. /*
  312.  * This routines selects or delects a gadget.
  313.  */
  314.  
  315. void SelectGadget(struct Window *Window, struct Gadget *G, int Bool) {
  316.  
  317.     register int pos;
  318.  
  319.     if ((Bool && (G->Flags & SELECTED)) || (!Bool && !(G->Flags & SELECTED))) return;
  320.     pos = RemoveGadget(Window, G);
  321.  
  322.     if (Bool) G->Flags |= SELECTED;
  323.         else G->Flags &= ~SELECTED;
  324.  
  325.     AddGadget(Window, G, pos);
  326.     WipeGadget(Window, G);
  327.     RefreshGList(G, Window, NULL, 1);
  328. }
  329.  
  330. /*
  331.  * This routines toggles a gadget.
  332.  */
  333.  
  334. void ToggleGadget(struct Window *Window, struct Gadget *G) {
  335.  
  336.     if (G->Flags & SELECTED)
  337.         SelectGadget(Window, G, FALSE);
  338.     else SelectGadget(Window, G, TRUE);
  339. }
  340.  
  341. /*
  342.  * This routine returns the address of a gadget. *MUCH* better than global data.
  343.  * If the gadget is disabled, returns NULL.
  344.  */
  345.  
  346. struct Gadget *GAddr(int GadgetNumber) {
  347.     return(Gadget[GadgetNumber].Flags & GADGDISABLED ? NULL : &Gadget[GadgetNumber]);
  348. }
  349.  
  350. /*
  351.  * EnableGadgets takes a mask of sizeof(Gadget)/sizeof(struct Gadget) bits and sets
  352.  * all of the gadgets accordingly. Notice that if all it's already OK, we don't
  353.  * do anything.
  354.  */
  355.  
  356. void EnableGadgets(struct Window *Window, int Mask) {
  357.  
  358.     register int i, pos=0;
  359.  
  360.     for(i=0; i<sizeof(Gadget)/sizeof(struct Gadget); i++)
  361.         pos |= ( (((1<<i) & Mask)!=0) != !(Gadget[i].Flags & GADGDISABLED) );
  362.     if (!pos) return;
  363.  
  364.     for(i=0; i<sizeof(Gadget)/sizeof(struct Gadget); i++) {
  365.         pos = RemoveGadget(Window, &Gadget[i]);
  366.  
  367.         if ((1<<i) & Mask) Gadget[i].Flags &= ~GADGDISABLED;
  368.         else Gadget[i].Flags |= GADGDISABLED;
  369.  
  370.         WipeGadget(Window, &Gadget[i]);
  371.         AddGadget(Window, &Gadget[i], pos);
  372.     }
  373.  
  374.     RefreshGList(Gadget, Window, NULL, sizeof(Gadget)/sizeof(struct Gadget));
  375. }
  376.