Requesters.c

   1 /*
   2 **      Requesters.c
   3 **
   4 **      Copyright (C) 1994,95,96,97 Bernardo Innocenti
   5 **
   6 **      Handle asyncronous file requester
   7 */
   8
   9 #include <exec/memory.h>
  10 #include <libraries/asl.h>
  11 #include <libraries/reqtools.h>
  12 #include <dos/dostags.h>
  13
  14 #include <proto/exec.h>
  15 #include <proto/dos.h>
  16 #include <proto/graphics.h>
  17 #include <proto/intuition.h>
  18 #include <proto/asl.h>
  19 #include <proto/reqtools.h>
  20
  21
  22 #include "XModulePriv.h"
  23 #include "Gui.h"
  24
  25
  26
  27 /* Local function prototypes */
  28 static LONG CheckOverwrite (CONST_STRPTR path);
  29
  30
  31
  32 /* This structure is used for passing parameters to
  33  * the requester process and to get the result back.
  34  */
  35 struct FileReqMsg
  36 {
  37         struct Message           ExecMsg;
  38         struct XMFileReq        *XMFReq;        /* XMFileReq structure to use           */
  39
  40         /* User call back function which does something with the file name.
  41          * If the user picked multiple files, the user function will be called
  42          * once on each selection.  The user function can tell which entry is
  43          * being processed examining the <num> and <count> arguments.
  44          */
  45         void    (*Func)(STRPTR file, ULONG num, ULONG count);
  46         APTR    Result;                                 /* Replied by FileRequester process     */
  47         UBYTE   PathName[PATHNAME_MAX]; /* Replied by FileRequester process     */
  48 };
  49
  50
  51
  52 XDEF struct XMFileReq FileReqs[FREQ_COUNT] =
  53 {
  54         { NULL, MSG_SELECT_MODULES,                     FRF_DOMULTISELECT | FRF_DOPATTERNS },
  55         { NULL, MSG_SAVE_MODULE,                        FRF_DOSAVEMODE | FRF_DOPATTERNS },
  56         { NULL, MSG_SELECT_INSTRUMENTS,         FRF_DOMULTISELECT | FRF_DOPATTERNS },
  57         { NULL, MSG_SAVE_INSTRUMENT,            FRF_DOSAVEMODE | FRF_DOPATTERNS },
  58         { NULL, MSG_SELECT_PATTERN,             FRF_DOPATTERNS },
  59         { NULL, MSG_SAVE_PATTERN,                       FRF_DOSAVEMODE | FRF_DOPATTERNS },
  60         { NULL, 0,                                                      FRF_DOPATTERNS },
  61         { NULL, 0,                                                      FRF_DOSAVEMODE | FRF_DOPATTERNS },
  62 };
  63
  64
  65 static APTR FontReq = NULL;
  66 static struct Process *FileReqTask = NULL;
  67 static struct MsgPort *FileReqPort = NULL;
  68 XDEF ULONG FileReqSig;
  69
  70
  71
  72
  73 /* This function is a process that puts out
  74  * an asyncronous ASL FileRequester.
  75  */
  76 HOOKCALL static void AslRequestProc (void)
  77 {
  78         struct MsgPort          *prMsgPort = &(((struct Process *)FindTask (NULL))->pr_MsgPort);
  79         struct FileReqMsg       *frmsg;
  80         struct XMFileReq        *xmfr;
  81
  82         /* Wait startup packet */
  83         WaitPort (prMsgPort);
  84         frmsg = (struct FileReqMsg *)GetMsg (prMsgPort);
  85         xmfr = frmsg->XMFReq;
  86         frmsg->Result = NULL;
  87
  88         if (AslRequestTags (xmfr->FReq,
  89                 ASLFR_Window,   ThisTask->pr_WindowPtr,
  90                 TAG_DONE))
  91         {
  92                 /* Build file path */
  93                 strncpy (frmsg->PathName,
  94                         ((struct FileRequester *)xmfr->FReq)->fr_Drawer, PATHNAME_MAX);
  95                 AddPart (frmsg->PathName,
  96                         ((struct FileRequester *)xmfr->FReq)->fr_File, PATHNAME_MAX);
  97                 frmsg->Result = frmsg->PathName;
  98         }
  99
 100         /* Signal that we are done.
 101          * We forbid here to avoid beeing unloaded until exit.
 102          */
 103         Forbid();
 104         ReplyMsg ((struct Message *)frmsg);
 105 }
 106
 107
 108
 109 /* This function is a process that puts out
 110  * an asyncronous ReqTools FileRequester.
 111  */
 112 HOOKCALL static void RtRequestProc (void)
 113 {
 114         struct MsgPort *prMsgPort = &(((struct Process *)FindTask(NULL))->pr_MsgPort);
 115         struct FileReqMsg *frmsg;
 116         struct XMFileReq *xmfr;
 117         ULONG flags = 0;
 118         UBYTE filename[PATHNAME_MAX];
 119
 120         filename[0] = 0;
 121
 122         /* Wait startup packet */
 123         WaitPort (prMsgPort);
 124         frmsg = (struct FileReqMsg *)GetMsg (prMsgPort);
 125         xmfr = frmsg->XMFReq;
 126
 127         if (xmfr->Flags & FRF_DOSAVEMODE)               flags |= FREQF_SAVE;
 128         if (xmfr->Flags & FRF_DOPATTERNS)               flags |= FREQF_PATGAD;
 129         if (xmfr->Flags & FRF_DOMULTISELECT)    flags |= FREQF_MULTISELECT;
 130
 131         if (!(frmsg->Result = rtFileRequest (xmfr->FReq, filename, STR(xmfr->Title),
 132                 RT_ShareIDCMP,  FALSE,
 133                 RT_Window,              ThisTask->pr_WindowPtr,
 134                 RTFI_Flags,             flags,
 135                 TAG_DONE)))
 136                 goto error;
 137
 138         /* Build file path */
 139         strncpy (frmsg->PathName, ((struct rtFileRequester *)xmfr->FReq)->Dir,
 140                 PATHNAME_MAX);
 141         AddPart (frmsg->PathName, filename, PATHNAME_MAX);
 142
 143         if (!(xmfr->Flags & FRF_DOMULTISELECT)) frmsg->Result = frmsg->PathName;
 144
 145 error:
 146         /* Signal that we are done.
 147          * We forbid here to avoid beeing unloaded until exit.
 148          */
 149         Forbid();
 150         ReplyMsg ((struct Message *)frmsg);
 151 }
 152
 153
 154
 155 GLOBALCALL LONG StartFileRequest (ULONG freq, void (*func)(STRPTR file, ULONG num, ULONG count))
 156
 157 /* Spawns a process that opens a FileRequester.
 158  * Do not touch freq until the child process returns!
 159  *
 160  * INPUTS
 161  *      freq - Pointer to an ASL or ReqTools FileRequester
 162  *      func - Pointer to a function to call when FileRequester returns
 163  *
 164  * RETURN
 165  *
 166  *  err - 0 if OK, IOErr()-style error otherwise.
 167  */
 168 {
 169         struct FileReqMsg *frmsg;
 170
 171         /* Do not spawn more than one file requester process at a time */
 172         if (FileReqTask)
 173         {
 174                 LastErr = ~0;
 175                 return RETURN_FAIL;
 176         }
 177
 178         if (!(frmsg = AllocMem (sizeof (struct FileReqMsg), MEMF_PUBLIC)))
 179                 return ERROR_NO_FREE_STORE;
 180
 181         if (!(FileReqTask = CreateNewProcTags (
 182                 NP_Entry,               (ReqToolsBase ? RtRequestProc : AslRequestProc),
 183                 NP_Name,                PRGNAME " FileRequester",
 184                 NP_CopyVars,    FALSE,
 185                 TAG_DONE)))
 186         {
 187                 FreeMem (frmsg, sizeof (struct FileReqMsg));
 188                 return ERROR_NO_FREE_STORE;
 189         }
 190
 191         /* Now setup & send FReqMsg */
 192         frmsg->ExecMsg.mn_ReplyPort = FileReqPort;
 193         frmsg->XMFReq = &FileReqs[freq];
 194         frmsg->Func = func;
 195         PutMsg (&(FileReqTask->pr_MsgPort), (struct Message *)frmsg);
 196
 197         return RETURN_OK;
 198 }
 199
 200
 201
 202 GLOBALCALL void HandleFileRequest (void)
 203 {
 204         struct FileReqMsg *frmsg;
 205         struct XMFileReq *xmfr;
 206
 207         if (!(frmsg = (struct FileReqMsg *)GetMsg (FileReqPort)))
 208                 return;
 209
 210         xmfr = frmsg->XMFReq;
 211
 212         FileReqTask = NULL;     /* The FileRequest Process is now gone. */
 213
 214         if (frmsg->Result)
 215         {
 216                 if (xmfr->Flags & FRF_DOMULTISELECT)
 217                 {
 218                         if (AslBase)
 219                         {
 220                                 struct FileRequester *fr = xmfr->FReq;
 221                                 UBYTE Name[PATHNAME_MAX];
 222                                 LONG i;
 223
 224                                 for (i = 0; i < fr->fr_NumArgs; i++)
 225                                 {
 226                                         if (NameFromLock (fr->fr_ArgList[i].wa_Lock, Name, PATHNAME_MAX))
 227                                                 if (AddPart (Name, fr->fr_ArgList[i].wa_Name, PATHNAME_MAX))
 228                                                         frmsg->Func (Name, i, fr->fr_NumArgs);
 229                                 }
 230                         }
 231                         else if (ReqToolsBase)
 232                         {
 233                                 struct rtFileList *fl;
 234                                 UBYTE Name[PATHNAME_MAX];
 235                                 ULONG num_entries = 0, i = 0;
 236
 237                                 /* Calculate number of entries in FileList */
 238                                 fl = (struct rtFileList *)frmsg->Result;
 239                                 while (fl)
 240                                 {
 241                                         fl = fl->Next;
 242                                         num_entries++;
 243                                 }
 244
 245                                 fl = (struct rtFileList *)frmsg->Result;
 246                                 while (fl)
 247                                 {
 248                                         strncpy (Name, ((struct rtFileRequester *)xmfr->FReq)->Dir, PATHNAME_MAX);
 249                                         AddPart (Name, fl->Name, PATHNAME_MAX);
 250                                         frmsg->Func (Name, i++, num_entries);
 251                                         fl = fl->Next;
 252                                 }
 253
 254                                 rtFreeFileList (frmsg->Result); /* Free multiselect buffer */
 255                         }
 256                 }
 257                 else
 258                         /* Call user hook */
 259                         frmsg->Func (frmsg->Result, 0, 1);
 260         }
 261
 262         FreeMem (frmsg, sizeof (struct FileReqMsg));    /* Free FileReqMsg */
 263 }
 264
 265
 266
 267 GLOBALCALL STRPTR FileRequest (ULONG freq, STRPTR file)
 268
 269 /* Puts up a simple FileRequester to ask the user for a filename.
 270  * If the requester is in save mode, will optionally check for
 271  * overwrite and ask the user to confirm.
 272  */
 273 {
 274         STRPTR retval = NULL;
 275         struct XMFileReq *xmfr = &FileReqs[freq];
 276         BOOL again;
 277
 278         if (!xmfr->FReq) return NULL;
 279
 280         LockWindows();
 281
 282         do
 283         {
 284                 again = FALSE;
 285
 286                 if (AslBase)
 287                 {
 288                         if (AslRequestTags (xmfr->FReq,
 289                                 ASLFR_Window,           ThisTask->pr_WindowPtr,
 290                                 ASLFR_InitialFile,      FilePart (file),
 291                                 TAG_DONE))
 292                         {
 293                                 /* Build file path */
 294                                 strncpy (file, ((struct FileRequester *)xmfr->FReq)->fr_Drawer,
 295                                         PATHNAME_MAX);
 296                                 AddPart (file, ((struct FileRequester *)xmfr->FReq)->fr_File,
 297                                         PATHNAME_MAX);
 298
 299                                 retval = file;
 300                         }
 301                 }
 302                 else if (ReqToolsBase)
 303                 {
 304                         UBYTE filename[PATHNAME_MAX];
 305                         ULONG flags = 0;
 306
 307
 308                         strncpy (filename, FilePart (file), PATHNAME_MAX);
 309
 310                         if (xmfr->Flags & FRF_DOSAVEMODE)               flags |= FREQF_SAVE;
 311                         if (xmfr->Flags & FRF_DOPATTERNS)               flags |= FREQF_PATGAD;
 312                         if (xmfr->Flags & FRF_DOMULTISELECT)    flags |= FREQF_MULTISELECT;
 313
 314                         if (rtFileRequest (xmfr->FReq, filename, (xmfr->Title == -1) ? NULL : STR(xmfr->Title),
 315                                 RT_ShareIDCMP,  TRUE,
 316                                 RTFI_Flags,             flags,
 317                                 TAG_DONE))
 318                         {
 319                                 /* Build file path */
 320                                 strncpy (file, ((struct rtFileRequester *)(xmfr->FReq))->Dir, PATHNAME_MAX);
 321                                 AddPart (file, filename, PATHNAME_MAX);
 322
 323                                 retval = file;
 324                         }
 325                 }
 326
 327
 328                 if (retval && (xmfr->Flags & FRF_DOSAVEMODE))
 329                 {
 330                         switch (CheckOverwrite (retval))
 331                         {
 332                                 case 1:                 /* Yes */
 333                                         break;
 334
 335                                 case 2:                 /* Choose Another */
 336                                         again = TRUE;
 337                                         break;
 338
 339                                 default:                /* No */
 340                                         retval = NULL;
 341                                         break;
 342                         }
 343                 }
 344
 345         } while (again);
 346
 347         UnlockWindows();
 348
 349         return retval;
 350 }
 351
 352
 353
 354 static LONG CheckOverwrite (CONST_STRPTR path)
 355
 356 /* Checks if the given file already exists and
 357  * kindly asks the user if he knows what he's doing.
 358  *
 359  * RETURN
 360  *              0 - Abort
 361  *              1 - Continue
 362  *              2 - Open the requester again
 363  */
 364 {
 365         if (GuiSwitches.AskOverwrite)
 366         {
 367                 BPTR fh;
 368
 369                 if (fh = Open (path, MODE_OLDFILE))
 370                 {
 371                         Close (fh);
 372
 373                         return ShowRequest (MSG_FILE_EXISTS, MSG_OVERWRITE, FilePart (path));
 374                 }
 375         }
 376
 377         return 1;
 378 }
 379
 380
 381
 382 GLOBALCALL LONG ShowRequestStr (CONST_STRPTR text, CONST_STRPTR gtext, APTR args)
 383
 384 /* Simple N-way requester function. Passing NULL as <gtext>
 385  * will put a single "Ok" button.  Will fall to a Printf()
 386  * when IntuitionBase is NULL.
 387  */
 388 {
 389         LONG ret;
 390
 391
 392         if (!gtext) gtext = STR(MSG_OK);
 393
 394         if (!ShowRequesters) return 1;
 395
 396         LockWindows();
 397
 398         if (ReqToolsBase)
 399         {
 400                 /* This silly thing gets around a nasty SAS/C 6.56 bug which
 401                  * causes a CXERR (and generates wrong code) when making a
 402                  * libcall with a parameter in A4.
 403                  */
 404                 volatile APTR rtargs = args;
 405
 406                 static LONG tags[] =
 407                 {
 408                         RTEZ_ReqTitle,  0,
 409                         RT_ShareIDCMP,  FALSE,
 410                         TAG_DONE
 411                 };
 412
 413                 tags[1] = (LONG)STR(MSG_XMODULE_REQUEST);
 414
 415                 ret = rtEZRequestA (text, gtext, NULL, rtargs, (struct TagItem *)tags);
 416         }
 417         else if (IntuitionBase)
 418         {
 419                 static struct EasyStruct es =
 420                 {
 421                         sizeof (struct EasyStruct),
 422                         0,
 423                         NULL,
 424                         NULL,
 425                         NULL
 426                 };
 427
 428                 es.es_Title                     = STR(MSG_XMODULE_REQUEST);
 429                 es.es_TextFormat        = (STRPTR)text;
 430                 es.es_GadgetFormat      = (STRPTR)gtext;
 431                 ret = EasyRequestArgs (ThisTask->pr_WindowPtr, &es, NULL, args);
 432         }
 433         else
 434         {
 435                 VPrintf (text, args);
 436                 FPutC (StdOut, (LONG)'\n');
 437                 ret = 1;
 438         }
 439
 440         UnlockWindows();
 441
 442         return ret;
 443 }
 444
 445
 446
 447 GLOBALCALL LONG ShowRequestArgs (ULONG msg, ULONG gadgets, APTR args)
 448
 449 /* Localized interface to ShowRequestStr(). The <msg> and
 450  * <gadgets> arguments are any MSG_#? from Locale.h.
 451  */
 452 {
 453         return ShowRequestStr (STR(msg), STR(gadgets), args);
 454 }
 455
 456
 457
 458 GLOBALCALL LONG ShowRequest (ULONG msg, ULONG gadgets, ...)
 459
 460 /* Localized, Variable arguments stub for ShowRequestStr()
 461  * The <msg> and <gadgets> arguments are any MSG_#? from Locale.h.
 462  */
 463 {
 464         return ShowRequestStr (STR(msg), STR(gadgets), (APTR)(((LONG *)(&gadgets))+1));
 465 }
 466
 467
 468
 469 GLOBALCALL LONG ScrModeRequest (struct ScrInfo *scrinfo)
 470
 471 /* Let user choose a new screen mode and store mode attributes in the ScrInfo
 472  * structure.
 473  *
 474  * Returns: TRUE for success, FALSE for failure.
 475  */
 476 {
 477         BOOL ChangeScreen = FALSE;
 478
 479         if (AslBase && AslBase->lib_Version >= 38)      /* ASL */
 480         {
 481                 struct ScreenModeRequester *ScrModeReq;
 482                 struct List customsmlist;
 483                 struct DisplayMode clonemode;
 484
 485
 486                 /* Setup custom screen mode for Workbench cloning */
 487
 488                 memset (&clonemode, 0, sizeof (clonemode));
 489
 490                 clonemode.dm_Node.ln_Name = STR(MSG_CLONE_WB);
 491                 clonemode.dm_DimensionInfo.Header.StructID = DTAG_DIMS;
 492                 clonemode.dm_DimensionInfo.Header.DisplayID = 0xFFFFFFFF;
 493                 clonemode.dm_DimensionInfo.Header.SkipID = TAG_SKIP;
 494                 clonemode.dm_DimensionInfo.Header.Length = (sizeof (struct DimensionInfo) - sizeof (struct QueryHeader)) / 2;
 495                 clonemode.dm_PropertyFlags = DIPF_IS_WB;
 496
 497                 NEWLIST (&customsmlist);
 498                 ADDHEAD (&customsmlist, (struct Node *)&clonemode);
 499
 500
 501                 if (ScrModeReq = AllocAslRequest (ASL_ScreenModeRequest, NULL))
 502                 {
 503                         LockWindows();
 504
 505                         if (AslRequestTags (ScrModeReq,
 506                                 ASLSM_Window,                           ThisTask->pr_WindowPtr,
 507                                 ASLSM_DoWidth,                          TRUE,
 508                                 ASLSM_DoHeight,                         TRUE,
 509                                 ASLSM_DoDepth,                          TRUE,
 510                                 ASLSM_DoOverscanType,           TRUE,
 511                                 ASLSM_DoAutoScroll,                     TRUE,
 512                                 ASLSM_InitialDisplayID,         GetVPModeID (&Scr->ViewPort),
 513                                 ASLSM_InitialDisplayWidth,      Scr->Width,
 514                                 ASLSM_InitialDisplayHeight,     Scr->Height,
 515                                 ASLSM_InitialDisplayDepth,      DrawInfo->dri_Depth,
 516                                 ASLSM_InitialAutoScroll,        Scr->Flags & AUTOSCROLL,
 517                                 ASLSM_InitialOverscanType,      scrinfo->OverscanType,
 518                                 ASLSM_MinWidth,                         640,
 519                                 ASLSM_MinHeight,                        200,
 520                                 ASLSM_CustomSMList,                     &customsmlist,
 521                                 TAG_DONE))
 522                         {
 523                                 if (ScrModeReq->sm_DisplayID == 0xFFFFFFFF)
 524                                         scrinfo->DisplayID = 0; /* Picked special clone WB mode */
 525                                 else
 526                                 {
 527                                         scrinfo->DisplayID = ScrModeReq->sm_DisplayID;
 528                                         scrinfo->Width = ScrModeReq->sm_DisplayWidth;
 529                                         scrinfo->Height = ScrModeReq->sm_DisplayHeight;
 530                                         scrinfo->Depth = ScrModeReq->sm_DisplayDepth;
 531                                         scrinfo->OverscanType = ScrModeReq->sm_OverscanType;
 532                                         scrinfo->AutoScroll = ScrModeReq->sm_AutoScroll;
 533                                 }
 534                                 ChangeScreen = TRUE;
 535                         }
 536
 537                         FreeAslRequest (ScrModeReq);
 538                         UnlockWindows();
 539                 }
 540         }
 541         else    /* ReqTools */
 542         {
 543                 struct rtScreenModeRequester *ScrModeReq;
 544                 BOOL CloseReqTools = FALSE;
 545
 546                 if (!ReqToolsBase)
 547                 {
 548                         if (!(ReqToolsBase = (struct ReqToolsBase *)
 549                                 OpenLibrary ("reqtools.library", 38)))
 550                         {
 551                                 CantOpenLib ("reqtools.library", 38);
 552                                 return FALSE;
 553                         }
 554                         CloseReqTools = TRUE;
 555                 }
 556
 557                 if (ScrModeReq = rtAllocRequestA (RT_SCREENMODEREQ, NULL))
 558                 {
 559                         LockWindows();
 560
 561                         if (rtScreenModeRequest (ScrModeReq, NULL,
 562                                 RTSC_Flags,             SCREQF_OVERSCANGAD | SCREQF_AUTOSCROLLGAD |
 563                                                                 SCREQF_SIZEGADS | SCREQF_DEPTHGAD | SCREQF_GUIMODES,
 564                                 RT_ShareIDCMP,  TRUE,
 565                                 TAG_DONE))
 566                         {
 567                                 scrinfo->DisplayID = ScrModeReq->DisplayID;
 568                                 scrinfo->Width = ScrModeReq->DisplayWidth;
 569                                 scrinfo->Height = ScrModeReq->DisplayHeight;
 570                                 scrinfo->Depth = ScrModeReq->DisplayDepth;
 571                                 scrinfo->OverscanType = ScrModeReq->OverscanType;
 572                                 scrinfo->AutoScroll = ScrModeReq->AutoScroll;
 573                                 ChangeScreen = TRUE;
 574                         }
 575
 576                         rtFreeRequest (ScrModeReq);
 577                         UnlockWindows();
 578                 }
 579
 580                 if (CloseReqTools)
 581                 {
 582                         CloseLibrary ((struct Library *)ReqToolsBase);
 583                         ReqToolsBase = NULL;
 584                 }
 585         }
 586
 587         return ChangeScreen;
 588 }
 589
 590
 591
 592 GLOBALCALL LONG FontRequest (struct TextAttr *ta, ULONG flags)
 593
 594 /* Requests a font to the user and copies the selected font to the
 595  * passed TextAttr structure.  The ta_Name field is allocated with
 596  * AllocVec() and the font name is copied to it.
 597  *
 598  * Returns: FALSE for failure, anything else for success.
 599  */
 600 {
 601         struct TextAttr *result = NULL;
 602
 603         LockWindows();
 604
 605         if (AslBase)
 606         {
 607                 if (AslRequestTags (FontReq,
 608                         ASLFO_Window,   ThisTask->pr_WindowPtr,
 609                         ASLFO_Flags,    FOF_DOSTYLE | flags,
 610                         TAG_DONE))
 611                                 result = &((struct FontRequester *)FontReq)->fo_Attr;
 612         }
 613         else if (ReqToolsBase)
 614         {
 615                 if (rtFontRequest (FontReq, NULL,
 616                         RT_ShareIDCMP,  TRUE,
 617                         RTFO_Flags,             FREQF_SCALE | FREQF_STYLE | ((flags & FOF_FIXEDWIDTHONLY) ? FREQF_FIXEDWIDTH : 0),
 618                         TAG_DONE))
 619                                 result = &((struct rtFontRequester *)FontReq)->Attr;
 620
 621         }
 622
 623         if (result) CopyTextAttrPooled (Pool, result, ta);
 624
 625         UnlockWindows();
 626
 627         return result != NULL;
 628 }
 629
 630
 631
 632 GLOBALCALL void FreeFReq (void)
 633 {
 634         ULONG i;
 635
 636         /* Terminate async requester */
 637         if (FileReqTask)
 638         {
 639                 while (!(SetSignal (0L, FileReqSig) & FileReqSig))
 640                         ShowRequest (MSG_CLOSE_FILEREQUESTER, MSG_CONTINUE, NULL);
 641
 642                 FileReqTask = NULL;
 643         }
 644
 645         if (FileReqPort)
 646         {
 647                 struct FileReqMsg *frmsg = (struct FileReqMsg *) GetMsg (FileReqPort);
 648
 649                 if (frmsg)
 650                 {
 651                         if ((frmsg->XMFReq->Flags & FRF_DOMULTISELECT) && ReqToolsBase)
 652                                 rtFreeFileList (frmsg->Result);
 653                         FreeMem (frmsg, sizeof (struct FileReqMsg));
 654                 }
 655
 656                 DeleteMsgPort (FileReqPort);    FileReqPort = NULL;
 657                 Signals &= ~FileReqSig;
 658         }
 659
 660         if (AslBase)
 661         {
 662                 for (i = 0; i < FREQ_COUNT; i++)
 663                 {
 664                         FreeAslRequest (FileReqs[i].FReq);
 665                         FileReqs[i].FReq = NULL;
 666                 }
 667
 668                 FreeAslRequest (FontReq);               FontReq = NULL;
 669                 CloseLibrary (AslBase);                 AslBase = NULL;
 670         }
 671
 672         if (ReqToolsBase)
 673         {
 674                 for (i = 0; i < FREQ_COUNT; i++)
 675                 {
 676                         rtFreeRequest (FileReqs[i].FReq);
 677                         FileReqs[i].FReq = NULL;
 678                 }
 679
 680                 rtFreeRequest (FontReq); FontReq = NULL;
 681                 CloseLibrary ((struct Library *)ReqToolsBase); ReqToolsBase = NULL;
 682         }
 683 }
 684
 685
 686
 687 GLOBALCALL LONG SetupAsl (void)
 688 {
 689         ULONG i;
 690         struct XMFileReq *xmfr;
 691
 692         if (!AslBase)
 693         {
 694                 if (!(AslBase = OpenLibrary ("asl.library", 37)))
 695                 {
 696                         CantOpenLib ("asl.library", 37);
 697                         return RETURN_FAIL;
 698                 }
 699         }
 700
 701         for (i = 0; i < FREQ_COUNT; i++)
 702         {
 703                 xmfr = &FileReqs[i];
 704
 705                 if (!(xmfr->FReq = AllocAslRequestTags (ASL_FileRequest,
 706                         (xmfr->Title == -1) ? TAG_IGNORE : ASLFR_TitleText, (xmfr->Title == -1) ? NULL : STR(xmfr->Title),
 707                         ASLFR_Flags1,           xmfr->Flags | FRF_PRIVATEIDCMP,
 708                         ASLFR_Flags2,           FRF_REJECTICONS,
 709                         TAG_DONE)))
 710                 return RETURN_FAIL;
 711
 712         }
 713
 714         if (!(FontReq = AllocAslRequestTags (ASL_FontRequest,
 715                 TAG_DONE)))
 716                 return RETURN_FAIL;
 717
 718         return RETURN_OK;
 719 }
 720
 721
 722
 723 GLOBALCALL LONG SetupReqTools (void)
 724 {
 725         ULONG i;
 726
 727         if (!(ReqToolsBase = (struct ReqToolsBase *)OpenLibrary ("reqtools.library", 38)))
 728         {
 729                 CantOpenLib ("reqtools.library", 38);
 730                 return RETURN_FAIL;
 731         }
 732
 733         for (i = 0; i < FREQ_COUNT; i++)
 734                 if (!(FileReqs[i].FReq = rtAllocRequestA (RT_FILEREQ, NULL)))
 735                         return RETURN_FAIL;
 736
 737         if (!(FontReq = rtAllocRequestA (RT_FONTREQ, NULL)))
 738                 return RETURN_FAIL;
 739
 740         return RETURN_OK;
 741 }
 742
 743
 744
 745 GLOBALCALL LONG SetupRequesters (void)
 746 {
 747         FreeFReq();
 748
 749         if (!FileReqPort)       /* Create FileRequester reply port */
 750         {
 751                 if (!(FileReqPort = CreateMsgPort ())) return ERROR_NO_FREE_STORE;
 752                 FileReqSig = 1 << FileReqPort->mp_SigBit;
 753                 Signals |= FileReqSig;
 754         }
 755
 756         if (GuiSwitches.UseReqTools)
 757         {
 758                 if (SetupReqTools())
 759                 {
 760                         GuiSwitches.UseReqTools = FALSE;
 761                         return SetupAsl();
 762                 }
 763         }
 764         else if (SetupAsl())
 765         {
 766                 GuiSwitches.UseReqTools = TRUE;
 767                 return SetupReqTools();
 768         }
 769
 770         return 0;
 771 }