home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 262.lha / SpriteWizard_v1.0 / SW_Req.c < prev    next >
C/C++ Source or Header  |  1989-06-30  |  15KB  |  554 lines
  1. /*  Requester toolbox  -  written and designed by David A. Visage  */
  2.  
  3. #include <stdio.h>
  4. #include <exec/types.h>
  5. #include <intuition/intuition.h>
  6.  
  7. #define REQ_GAD_HEIGHT 13         /*  Requester Gadget = 13 pixels  */
  8. #define STR_GADGET_HEIGHT 10      /*  String Gadgets = 10 pixels    */
  9.  
  10. #define MAX_STR_LEN  256          /*  Maximum string input length  */
  11.  
  12. #define STR_GAD_ID   5
  13. #define TEXT_WIDTH   8
  14.  
  15. #define MAX_WIDTH   640
  16. #define MAX_HEIGHT  200
  17.  
  18. #define COLOR00  0
  19. #define COLOR05  5
  20.  
  21. /*  These define the number of random sorry and continue messages  */
  22. #define SORRY_COUNT  8
  23. #define CONT_COUNT   8
  24.  
  25. /*  Declare return values from requester functions  */
  26. extern struct Message *GetMsg();
  27. extern LONG InitIText();
  28. extern LONG IntuiTextLength();
  29. extern USHORT WaitForGadget();
  30. extern BOOL GetString();
  31. extern unsigned int GetRand();
  32.  
  33. /*  The famous points structure  */
  34. struct Points
  35.  {
  36.  SHORT X1,Y1;
  37.  SHORT X2,Y2;
  38.  SHORT X3,Y3;
  39.  SHORT X4,Y4;
  40.  SHORT X5,Y5;
  41.  };
  42.  
  43. /*  Used for rendering requesters  */
  44. struct ReqData
  45.  {
  46.  struct Requester ReqRequest;
  47.  struct Border ReqBorder;
  48.  struct Points ReqPoints;
  49.  struct IntuiText ReqIText[25];          /*  Holds requester text  */
  50.  };
  51.  
  52. /*  Used for rendering requester gadgets  */
  53. struct ReqGadData
  54.  {
  55.  struct Gadget ReqGadget;
  56.  struct Border ReqGadBorder;
  57.  struct Points ReqGadPoints;
  58.  struct IntuiText ReqGadIText[2];     /*  Leave room for InitIText NULL  */
  59.  };
  60.  
  61. /*  Used for rendering string gadgets  */
  62. struct StrGadData
  63.  {
  64.  struct Gadget StrGad;
  65.  struct Border StrGadBorder;
  66.  struct Points StrGadPoints;
  67.  struct StringInfo StrGadInfo;
  68.  UBYTE StrGadBuffer [MAX_STR_LEN];
  69.  };
  70.  
  71. /*  SpriteWiz continue message  */
  72. char *ContMsg[] = { NULL,NULL };
  73.  
  74. /*  These ought to liven things up a bit  */
  75. char *ContArray[] = {
  76.   "CONTINUE",
  77.   "WHATEVER",
  78.   "WHO CARES",
  79.   "YOU SAID IT",
  80.   "I BELIEVE IT",
  81.   "YOU BET YOUR LIFE",
  82.   "AFFIRMATIVE",
  83.   "10-4 GOOD BUDDY" };
  84.  
  85. /*  SpriteWiz error message  */
  86. char *SorryMsg[] = { NULL,NULL };
  87.  
  88. /*  More funny messages  */
  89. char *SorryArray[] = {
  90.   "OOPS",
  91.   "SORRY",
  92.   "MY FAULT",
  93.   "I BLEW IT",
  94.   "MY MISTAKE",
  95.   "FORGET IT",
  96.   "AW SHUCKS",
  97.   "NO PROBLEM" };
  98.  
  99. /*  SpriteWiz yes/no gadget text  */
  100. char *OkayMsg[] = { " OKAY ",NULL };
  101. char *NahMsg[]  = { "CANCEL",NULL };
  102.  
  103. char *AuthorMsg [] = {
  104. "Sprite Wizard V1.0",
  105. " ",
  106. "Written and designed by David A. Visage",
  107. " ",
  108. "(C) 1988 Message Software",
  109. "James Messa and David Visage",
  110. "Our Logo - GET THE MESSAGE!",
  111. " ",
  112. "Comments and/or suggestions are welcome!",
  113. " ",
  114. "Home : (916) 383-0986",
  115. "Work : (916) 446-8550",
  116. " ",
  117. "Also by David Visage  -  Disk Wizard V1.0",
  118. "                         Mind Expander!",
  119. NULL };
  120.  
  121. char *PgmMsg[] = {
  122. "Sprite Wizard is a Multi-Purpose sprite editor/animator designed",
  123. "to take the pain out of designing and animating hardware sprites",
  124. "and VSprites.",
  125. " ",
  126. "Although this version of Sprite Wizard only works with sprites",
  127. "16 pixels wide by 16 pixels high, I believe you will find a lot",
  128. "of useful options are available.",
  129. " ",
  130. "If I decide to make V2.0 of Sprite Wizard, sprites will be editable",
  131. "up to 192 pixels high.",
  132. " ",
  133. "Have Fun, and remember - Your comments are the deciding factor as to",
  134. "whether or not V2.0 of Sprite Wizard will become a reality!",
  135. NULL };
  136.  
  137. char *MoneyMsg[] = {
  138. "This is a demo version of Sprite Wizard V1.0 that has the save",
  139. "C source and save Assembler source options disabled.",
  140. " ",
  141. "If you find Sprite Wizard useful, you can get a full working",
  142. "copy by mailing me a self-addressed stamped envelope, a blank",
  143. "disk, and a check or money order for five dollars.",
  144. "If you are just learning to use the Amiga, you might find the",
  145. "C source code for Sprite Wizard useful.  Thus, For an additional",
  146. "ten dollars, the source code for Sprite Wizard can be yours.",
  147. " ",
  148. "David A. Visage",
  149. "7371 Power Inn Road #106",
  150. "Sacramento, Ca. 95826",
  151. NULL };
  152.  
  153. char *ErrMsg[] =
  154.  {
  155.  NULL,
  156.  " ",
  157.  NULL
  158.  };
  159.  
  160. char *GetStrMsg[] =
  161.  {
  162.  NULL,
  163.  " ",
  164.  NULL
  165.  };
  166.  
  167. /*  Handle Author requester  */
  168. Author(WindowPtr)
  169. struct Window *WindowPtr;
  170. {
  171. struct ReqData MyRequest;
  172. struct Requester *RequestPtr;
  173. struct ReqGadData YesGad;
  174. struct Gadget *GadgetPtr;
  175. unsigned int RandVal;
  176. USHORT GadID;
  177.  
  178. BuildRequest(&MyRequest,AuthorMsg);      /*  Build Author request  */
  179. RequestPtr = &MyRequest.ReqRequest;
  180.  
  181. /*  Get random continue message  */
  182. RandVal = GetRand(CONT_COUNT);
  183. ContMsg[0] = ContArray[RandVal];
  184.  
  185. BuildReqGadget(&YesGad,ContMsg,TRUE);   /*  Build true requester gadget  */
  186. GadgetPtr = &YesGad.ReqGadget;
  187.  
  188. /*  Link gadget to requester, do request, and wait for gadget  */
  189. RequestPtr->ReqGadget = GadgetPtr;
  190. Request(RequestPtr,WindowPtr);
  191. GadID = WaitForGadget(WindowPtr);   /*  Wait until RELVERIFY gadget hit  */
  192. }
  193.  
  194.  
  195. /*  Handle Program requester  */
  196. Program(WindowPtr)
  197. struct Window *WindowPtr;
  198. {
  199. struct ReqData MyRequest;
  200. struct Requester *RequestPtr;
  201. struct ReqGadData YesGad;
  202. struct Gadget *GadgetPtr;
  203. unsigned int RandVal;
  204. USHORT GadID;
  205.  
  206. BuildRequest(&MyRequest,PgmMsg);     /*  Build program request  */
  207. RequestPtr = &MyRequest.ReqRequest;
  208.  
  209. /*  Get random continue message  */
  210. RandVal = GetRand(CONT_COUNT);
  211. ContMsg[0] = ContArray[RandVal];
  212.  
  213. BuildReqGadget(&YesGad,ContMsg,TRUE);   /*  Build true requester gadget  */
  214. GadgetPtr = &YesGad.ReqGadget;
  215.  
  216. /*  Link gadget to requester, do request, and wait for gadget  */
  217. RequestPtr->ReqGadget = GadgetPtr;
  218. Request(RequestPtr,WindowPtr);
  219. GadID = WaitForGadget(WindowPtr);   /*  Wait until RELVERIFY gadget hit  */
  220. }
  221.  
  222.  
  223. /*  Handle Money requester  */
  224. Money(WindowPtr)
  225. struct Window *WindowPtr;
  226. {
  227. struct ReqData MyRequest;
  228. struct Requester *RequestPtr;
  229. struct ReqGadData YesGad;
  230. struct Gadget *GadgetPtr;
  231. unsigned int RandVal;
  232. USHORT GadID;
  233.  
  234. BuildRequest(&MyRequest,MoneyMsg);      /*  Build Money request  */
  235. RequestPtr = &MyRequest.ReqRequest;
  236.  
  237. /*  Get random continue message  */
  238. RandVal = GetRand(CONT_COUNT);
  239. ContMsg[0] = ContArray[RandVal];
  240.  
  241. BuildReqGadget(&YesGad,ContMsg,TRUE);   /*  Build true requester gadget  */
  242. GadgetPtr = &YesGad.ReqGadget;
  243.  
  244. /*  Link gadget to requester, do request, and wait for gadget  */
  245. RequestPtr->ReqGadget = GadgetPtr;
  246. Request(RequestPtr,WindowPtr);
  247. GadID = WaitForGadget(WindowPtr);   /*  Wait until RELVERIFY gadget hit  */
  248. }
  249.  
  250.  
  251. /*  Handle SpriteWiz errors  */
  252. ErrRequest(WindowPtr,Heading)
  253. struct Window *WindowPtr;
  254. char *Heading;
  255. {
  256. struct ReqData MyRequest;
  257. struct Requester *RequestPtr;
  258. struct ReqGadData YesGad;
  259. struct Gadget *GadgetPtr;
  260. unsigned int RandVal;
  261. USHORT GadID;
  262.  
  263. /*  Assign error message to requester heading  */
  264. ErrMsg[0] = Heading;
  265. BuildRequest(&MyRequest,ErrMsg);     /*  Build program request  */
  266. RequestPtr = &MyRequest.ReqRequest;
  267.  
  268. /*  Get a random sorry message  */
  269. RandVal = GetRand(SORRY_COUNT);
  270. SorryMsg[0] = SorryArray[RandVal];
  271.  
  272. BuildReqGadget(&YesGad,SorryMsg,TRUE);   /*  Build true requester gadget  */
  273. GadgetPtr = &YesGad.ReqGadget;
  274.  
  275. /*  Link gadget to requester, do request, and wait for gadget  */
  276. RequestPtr->ReqGadget = GadgetPtr;
  277. Request(RequestPtr,WindowPtr);
  278. GadID = WaitForGadget(WindowPtr);   /*  Wait until RELVERIFY gadget hit  */
  279. }
  280.  
  281.  
  282. /*  Accept input string in requester  */
  283. BOOL GetString(WindowPtr,Heading,BufferPtr)
  284. struct Window *WindowPtr;
  285. char *Heading;                  /*  Text for string entry requester  */
  286. UBYTE *BufferPtr;
  287. {
  288. struct ReqData MyRequest;
  289. struct Requester *RequestPtr;
  290. struct ReqGadData YesGad,NoGad;
  291. struct StrGadData InputGad;
  292. struct Gadget *GadgetPtr;
  293. UBYTE *DestBuffer,*SrcBuffer;
  294. USHORT GadID;
  295.  
  296. GetStrMsg[0] = Heading;
  297. BuildRequest(&MyRequest,GetStrMsg);         /*  Build string request  */
  298. RequestPtr = &MyRequest.ReqRequest;
  299.  
  300. BuildReqGadget(&YesGad,OkayMsg,TRUE);       /*  Build true gadget   */
  301. BuildReqGadget(&NoGad,NahMsg,FALSE);        /*  Build false gadget  */
  302.  
  303. DestBuffer = &InputGad.StrGadBuffer[0];
  304. strcpy(DestBuffer,BufferPtr);               /*  Copy user buffer  */
  305. BuildStrGadget(&InputGad);                  /*  Build string gadget  */
  306.  
  307. /*  Link string gadget to false gadget  */
  308. GadgetPtr = &NoGad.ReqGadget;
  309. GadgetPtr->NextGadget = &InputGad.StrGad;
  310.  
  311. /*  Link false gadget to true gadget  */
  312. GadgetPtr = &YesGad.ReqGadget;
  313. GadgetPtr->NextGadget = &NoGad.ReqGadget;
  314.  
  315. /*  Link true gadget to requester, do request, and wait for gadget  */
  316. RequestPtr->ReqGadget = GadgetPtr;
  317. Request(RequestPtr,WindowPtr);
  318. GadID = WaitForGadget(WindowPtr);
  319.  
  320. /*  Check if string is copied to user buffer  */
  321. if ( GadID != FALSE )
  322.    {
  323.    SrcBuffer = &InputGad.StrGadBuffer[0];
  324.    strcpy(BufferPtr,SrcBuffer);
  325.    return(TRUE);
  326.    };
  327. return(FALSE);
  328. }
  329.  
  330.  
  331. /*  Take the pain out of creating complex requesters  */
  332. BuildRequest(ReqDataPtr,StrPtr)
  333. struct ReqData *ReqDataPtr;
  334. char *StrPtr[];
  335. {
  336. struct Requester *RequestPtr;
  337. struct Border *BorderPtr;
  338. struct Points *PointsPtr;
  339. struct IntuiText *ITextPtr;
  340. LONG ITextLen;
  341. SHORT Width,Height;
  342. SHORT ReqWidth,ReqHeight;
  343. LONG Count;
  344.  
  345. /*  Extract information from ReqData structure  */
  346. RequestPtr = &ReqDataPtr->ReqRequest;
  347. BorderPtr = &ReqDataPtr->ReqBorder;
  348. PointsPtr = &ReqDataPtr->ReqPoints;
  349. ITextPtr = &ReqDataPtr->ReqIText[0];
  350.  
  351. /*  Initialize requester IText and calculate width and height  */
  352. InitRequester(RequestPtr);
  353. ITextLen = InitIText(ITextPtr,StrPtr,&Count);
  354. ReqWidth = ITextLen + (TEXT_WIDTH * 2);
  355. ReqHeight = Count * 10;
  356.  
  357. /*  Initialize requester information  */
  358. RequestPtr->LeftEdge = (MAX_WIDTH - ReqWidth) / 2;
  359. RequestPtr->TopEdge = (MAX_HEIGHT - ReqHeight) / 2;
  360. RequestPtr->Width = ReqWidth;
  361. RequestPtr->Height = ReqHeight + REQ_GAD_HEIGHT;    /*  Room for gadgets  */
  362. RequestPtr->ReqText = ITextPtr;
  363. RequestPtr->Flags = NULL;
  364. RequestPtr->BackFill = COLOR05;
  365.  
  366. /*  Build requester border and link into requester  */
  367. Width = RequestPtr->Width - 1;
  368. Height = RequestPtr->Height - 1;
  369. InitBorder(PointsPtr,BorderPtr,Width,Height);
  370. RequestPtr->ReqBorder = BorderPtr;
  371. }
  372.  
  373.  
  374. /*  Take some of the hassle out of creating requester gadgets  */
  375. BuildReqGadget(GadDataPtr,StrPtr,GadType)
  376. struct ReqGadData *GadDataPtr;
  377. char *StrPtr[];
  378. USHORT GadType;
  379. {
  380. struct Gadget *GadgetPtr;
  381. struct Border *BorderPtr;
  382. struct Points *PointsPtr;
  383. struct IntuiText *ITextPtr;
  384. LONG ITextLen,Count;
  385. SHORT Width,Height,ReqGadWidth;
  386.  
  387. /*  Extract information from ReqGadData structure  */
  388. GadgetPtr = &GadDataPtr->ReqGadget;
  389. BorderPtr = &GadDataPtr->ReqGadBorder;
  390. PointsPtr = &GadDataPtr->ReqGadPoints;
  391. ITextPtr = &GadDataPtr->ReqGadIText[0];
  392.  
  393. /*  Initialize gadget IText and calculate width  */
  394. ITextLen = InitIText(ITextPtr,StrPtr,&Count);
  395. ReqGadWidth = ITextLen + (TEXT_WIDTH * 2);
  396.  
  397. /*  Intialize gadget information  */
  398. GadgetPtr->TopEdge = - ( AUTOTOPEDGE + REQ_GAD_HEIGHT );
  399. GadgetPtr->Width = ReqGadWidth;
  400. GadgetPtr->Height = REQ_GAD_HEIGHT;
  401. GadgetPtr->Activation = RELVERIFY | ENDGADGET;
  402. GadgetPtr->GadgetType = BOOLGADGET | REQGADGET;
  403. GadgetPtr->GadgetText = ITextPtr;
  404. GadgetPtr->GadgetID = GadType;
  405. GadgetPtr->NextGadget = NULL;
  406. if ( GadType == TRUE )
  407.    {
  408.    GadgetPtr->Flags = GADGHCOMP | GRELBOTTOM | GRELRIGHT;
  409.    GadgetPtr->LeftEdge = - ( TEXT_WIDTH + ReqGadWidth );
  410.    }
  411. else
  412.    {
  413.    GadgetPtr->Flags = GADGHCOMP | GRELBOTTOM;
  414.    GadgetPtr->LeftEdge = TEXT_WIDTH;
  415.    };
  416.  
  417. /*  Build requester gadget border and link into gadget  */
  418. Width = GadgetPtr->Width - 1;
  419. Height = GadgetPtr->Height - 1;
  420. InitBorder(PointsPtr,BorderPtr,Width,Height);
  421. GadgetPtr->GadgetRender = (APTR) BorderPtr;
  422. }
  423.  
  424.  
  425. /*  Create a String Gadget for display in a requester  */
  426. BuildStrGadget(GadDataPtr)
  427. struct StrGadData *GadDataPtr;
  428. {
  429. struct Gadget *GadgetPtr;
  430. struct Border *BorderPtr;
  431. struct Points *PointsPtr;
  432. struct StringInfo *StrInfoPtr;
  433. UBYTE *BufferPtr;
  434. USHORT Width,Height;
  435.  
  436. /*  Extract information from StrGadData structure  */
  437. GadgetPtr = &GadDataPtr->StrGad;
  438. BorderPtr = &GadDataPtr->StrGadBorder;
  439. PointsPtr = &GadDataPtr->StrGadPoints;
  440. StrInfoPtr = &GadDataPtr->StrGadInfo;
  441. BufferPtr = &GadDataPtr->StrGadBuffer[0];
  442.  
  443. /*  Intialize string info for gadget  */
  444. StrInfoPtr->Buffer = BufferPtr;
  445. StrInfoPtr->UndoBuffer = BufferPtr;
  446. StrInfoPtr->BufferPos = 0;
  447. StrInfoPtr->MaxChars = MAX_STR_LEN - 1;         /*  Allow for '/0'  */
  448. StrInfoPtr->DispPos = 0;
  449.  
  450. /*  Initialize string gadget information  */
  451. GadgetPtr->LeftEdge = 11 * TEXT_WIDTH;
  452. GadgetPtr->TopEdge = - ( AUTOTOPEDGE + STR_GADGET_HEIGHT );
  453. GadgetPtr->Height = STR_GADGET_HEIGHT;
  454. GadgetPtr->Width =  20 * TEXT_WIDTH;            /*  Select box width  */
  455. GadgetPtr->Flags = GADGHCOMP | GRELBOTTOM;
  456. GadgetPtr->Activation = RELVERIFY | ENDGADGET;
  457. GadgetPtr->GadgetType = STRGADGET | REQGADGET;
  458. GadgetPtr->GadgetText = NULL;
  459. GadgetPtr->GadgetID = STR_GAD_ID;               /*  String gadget ID  */
  460. GadgetPtr->NextGadget = NULL;
  461. GadgetPtr->SpecialInfo = (APTR) StrInfoPtr;
  462.  
  463. /*  Make border and link to string gadget  */ 
  464. Width = GadgetPtr->Width + 1;
  465. Height = GadgetPtr->Height - 1;
  466.  
  467. InitBorder(PointsPtr,BorderPtr,Width,Height);
  468.  
  469. BorderPtr->LeftEdge = - 1;
  470. BorderPtr->TopEdge = - 1;
  471. GadgetPtr->GadgetRender = (APTR) BorderPtr;
  472. }
  473.  
  474.  
  475. /*  Link IntuiText together and return pixel length of the longest one  */
  476. LONG InitIText(ITextPtr,StrPtr,CountPtr)
  477. struct IntuiText *ITextPtr;
  478. char *StrPtr[];
  479. LONG *CountPtr;
  480. {
  481. struct IntuiText *NextTextPtr;        /*  Points to next IntuiText  */
  482. BOOL Finished;
  483. LONG MaxTextLen,TextLen,Count;
  484. int i;
  485.  
  486.  
  487. i = MaxTextLen = 0; Count = 1; Finished = FALSE;
  488.  
  489. while  ( ! Finished )
  490.    {
  491.    /*  Initilize IntuiText  */
  492.    ITextPtr->FrontPen = COLOR00;
  493.    ITextPtr->BackPen = COLOR05;
  494.    ITextPtr->DrawMode = JAM1;
  495.    ITextPtr->LeftEdge = TEXT_WIDTH;
  496.    ITextPtr->TopEdge = AUTOTOPEDGE + ( i * 9 );
  497.    ITextPtr->ITextFont = NULL;
  498.    ITextPtr->IText = (UBYTE *) StrPtr[i];
  499.  
  500.    /*  Check length of this IntuiText  */
  501.    TextLen = IntuiTextLength(ITextPtr);
  502.    if ( TextLen > MaxTextLen )
  503.       MaxTextLen = TextLen;         /*  IntuiText length in pixels  */
  504.  
  505.    i++;
  506.    NextTextPtr = ITextPtr + 1;      /*  Auto scaled by argument size  */
  507.  
  508.    if ( StrPtr[i] != NULL )
  509.       {
  510.       ITextPtr->NextText = NextTextPtr;
  511.       ITextPtr++;                         /*  Get next IntuiText  */
  512.       Count++;
  513.       }
  514.    else
  515.       {
  516.       ITextPtr->NextText = NULL;
  517.       Finished = TRUE;
  518.       };
  519.    };
  520.  
  521. *CountPtr = Count;
  522. return(MaxTextLen);          /*  return maximum IntuiText length  */
  523. }
  524.  
  525.  
  526. /*  Wait until requester gadget hit and return GadgetID  */
  527. USHORT WaitForGadget(WindowPtr)
  528. struct Window *WindowPtr;
  529. {
  530. struct IntuiMessage *MessagePtr;
  531. USHORT GadID;
  532. struct Gadget *GadgetPtr;
  533. BOOL Done;
  534.  
  535. Done = FALSE;
  536. while ( ! Done )
  537.    {
  538.    MessagePtr = (struct IntuiMessage *) GetMsg(WindowPtr->UserPort);
  539.    if ( MessagePtr != NULL )
  540.       {
  541.       ReplyMsg(MessagePtr);
  542.       if ( MessagePtr->Class == GADGETUP )
  543.          {
  544.          GadgetPtr = (struct Gadget *) MessagePtr->IAddress;
  545.          GadID = GadgetPtr->GadgetID;
  546.          Done = TRUE;
  547.          };
  548.       };
  549.    };
  550. return(GadID);
  551. }
  552.  
  553.  
  554.