workbench/libs/asl/filereqsupport.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6
   7 #include <proto/exec.h>
   8 #include <proto/dos.h>
   9 #include <proto/intuition.h>
  10 #include <proto/graphics.h>
  11 #include <proto/utility.h>
  12 #include <exec/memory.h>
  13 #include <dos/dos.h>
  14 #include <dos/exall.h>
  15 #include <dos/dosasl.h>
  16 #include <dos/datetime.h>
  17 #include <dos/filehandler.h>
  18 #include <intuition/gadgetclass.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <clib/macros.h>
  22
  23 #include "asl_intern.h"
  24 #include "filereqsupport.h"
  25 #include "filereqhooks.h"
  26 #include "specialreq.h"
  27 #include "layout.h"
  28
  29 #define CATCOMP_NUMBERS
  30 #include "strings.h"
  31
  32 #define SDEBUG 0
  33 #define DEBUG 0
  34 //#define ADEBUG 0
  35
  36 #include <aros/debug.h>
  37
  38 /*****************************************************************************************/
  39
  40 static WORD FRCompareDirectoryNodes(struct IntFileReq *ifreq, struct ASLLVFileReqNode *node1,
  41                                     struct ASLLVFileReqNode *node2, struct AslBase_intern *AslBase);
  42
  43
  44 /*****************************************************************************************/
  45
  46 static void fixpath(char *pathstring)
  47 {
  48     char *start;
  49     WORD i, len;
  50
  51     /* tricky slash stuff:
  52
  53        work:pictures/     --> work:pictures
  54        work:pictures//    --> work:
  55        work:pictures///   --> work:/
  56        work:pictures////  --> work://
  57        /pics/             --> /pics
  58        /pics//            --> /
  59        /pics///           --> //
  60        /pics//pics        --> /pics
  61        /pics//pics/       --> /pics
  62        /pics/scans////    --> //
  63
  64     */
  65
  66     start = strrchr(pathstring,':');
  67     if (start)
  68     {
  69         start++;
  70     } else {
  71         start = pathstring;
  72     }
  73
  74     for(; (i = len = strlen(start)); )
  75     {
  76         char *sp = start;
  77
  78         /* skip leading slashes */
  79
  80         while(i && (*sp == '/'))
  81         {
  82             i--;
  83             sp++;
  84         }
  85
  86         if (i)
  87         {
  88             char *sp2;
  89
  90             if((sp2 = strstr(sp, "//")))
  91             {
  92                 char *sp3 = sp2;
  93
  94                 while(sp3 > sp)
  95                 {
  96                     char c = sp3[-1];
  97
  98                     if (c == '/') break;
  99                     sp3--;
 100                 }
 101
 102                 memmove(sp3, sp2 + 2, strlen(sp2 + 2) + 1);
 103
 104                 continue;
 105             }
 106
 107         } /* if path is something more than just leading slashes */
 108
 109         break;
 110
 111     } /* for(; (i = len = strlen(start)); ) */
 112
 113     /* kill trailing slash */
 114
 115     i = strlen(start);
 116     if (i >= 2)
 117     {
 118         if ((start[i - 1] == '/') &&
 119             (start[i - 2] != '/'))
 120         {
 121             start[--i] = '\0';
 122         }
 123     }
 124 }
 125
 126 /*****************************************************************************************/
 127
 128 void FRRefreshListview(struct LayoutData *ld, struct AslBase_intern *AslBase)
 129 {
 130     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
 131     struct TagItem      set_tags[] =
 132     {
 133         {ASLLV_Labels, (IPTR)&udata->ListviewList       },
 134         {TAG_DONE                                       }
 135     };
 136
 137     SetGadgetAttrsA((struct Gadget *)udata->Listview, ld->ld_Window, NULL, set_tags);
 138 }
 139
 140 /*****************************************************************************************/
 141
 142 void FRFreeListviewNode(struct ASLLVFileReqNode *node, struct LayoutData *ld, struct AslBase_intern *AslBase)
 143 {
 144     WORD i;
 145
 146     for(i = 0; i < ASLLV_MAXCOLUMNS; i++)
 147     {
 148         if (node->text[i] && !(node->dontfreetext & (1 << i)))
 149         {
 150             FreePooled(ld->ld_IntReq->ir_MemPool, node->text[i], strlen(node->text[i]) + 1);
 151         }
 152     }
 153
 154 #ifdef __MORPHOS__
 155     if (node->type == ASLLV_FRNTYPE_VOLUMES)
 156         FreePooled(ld->ld_IntReq->ir_MemPool, node->node.ln_Name, strlen(node->node.ln_Name) + 1);
 157 #endif
 158
 159     FreePooled(ld->ld_IntReq->ir_MemPool, node, sizeof(struct ASLLVFileReqNode));
 160 }
 161
 162 /*****************************************************************************************/
 163
 164 void FRFreeListviewList(struct LayoutData *ld, struct AslBase_intern *AslBase)
 165 {
 166     struct FRUserData           *udata = (struct FRUserData *)ld->ld_UserData;
 167     struct ASLLVFileReqNode     *node, *succ;
 168     struct TagItem              set_tags [] =
 169     {
 170         {ASLLV_Labels   , 0     },
 171         {TAG_DONE               }
 172     };
 173
 174     if (udata->Listview)
 175     {
 176         SetGadgetAttrsA((struct Gadget *)udata->Listview, ld->ld_Window, NULL, set_tags);
 177     }
 178
 179     ForeachNodeSafe(&udata->ListviewList, node, succ)
 180     {
 181         FRFreeListviewNode(node, ld, AslBase);
 182     }
 183
 184     NEWLIST(&udata->ListviewList);
 185 }
 186
 187
 188 /*****************************************************************************************/
 189
 190 void FRReSortListview(struct LayoutData *ld, struct AslBase_intern *AslBase)
 191 {
 192     struct FRUserData           *udata = (struct FRUserData *)ld->ld_UserData;
 193     struct IntFileReq           *ifreq = (struct IntFileReq *)ld->ld_IntReq;
 194     struct Node                 *node, *succ;
 195     struct List                 templist;
 196     struct TagItem              set_tags [] =
 197     {
 198         {ASLLV_Labels   , 0     },
 199         {ASLLV_Top      , 0     },
 200         {TAG_DONE               }
 201     };
 202     IPTR                        old_top;
 203
 204     if (udata->Flags & FRFLG_SHOWING_VOLUMES) return;
 205
 206     GetAttr(ASLLV_Top, udata->Listview, &old_top);
 207
 208     SetGadgetAttrsA((struct Gadget *)udata->Listview, ld->ld_Window, NULL, set_tags);
 209
 210     NEWLIST(&templist);
 211
 212     ForeachNodeSafe(&udata->ListviewList, node, succ)
 213     {
 214         Remove(node);
 215         MARK_UNSELECTED(node);
 216         AddTail(&templist, node);
 217     }
 218
 219     ForeachNodeSafe(&templist, node, succ)
 220     {
 221         SortInNode(ifreq, &udata->ListviewList, node, (APTR)FRCompareDirectoryNodes, AslBase);
 222     }
 223
 224     set_tags[0].ti_Data = (IPTR)&udata->ListviewList;
 225     set_tags[1].ti_Data = old_top;
 226
 227     SetGadgetAttrsA((struct Gadget *)udata->Listview, ld->ld_Window, NULL, set_tags);
 228 }
 229
 230 /*****************************************************************************************/
 231
 232 void FRDirectoryScanSymbolState(struct LayoutData *ld, BOOL on, struct AslBase_intern *AslBase)
 233 {
 234
 235     if (ld->ld_Window)
 236     {
 237         struct FRUserData       *udata = (struct FRUserData *)ld->ld_UserData;
 238         struct TagItem          set_tags[] =
 239         {
 240             {GA_Selected        , on    },
 241             {TAG_DONE           }
 242         };
 243
 244         SetAttrsA(udata->DirectoryScanSymbol, set_tags);
 245         RefreshGList((struct Gadget *)udata->DirectoryScanSymbol, ld->ld_Window, NULL, 1);
 246     }
 247 }
 248
 249 /*****************************************************************************************/
 250
 251 static void FRCalcColumnWidths(struct LayoutData *ld, struct AslBase_intern *AslBase)
 252 {
 253     struct FRUserData           *udata = (struct FRUserData *)ld->ld_UserData;
 254     struct ASLLVFileReqNode     *node;
 255     WORD                        i;
 256
 257     for(i = 0; i < ASLLV_MAXCOLUMNS; i++)
 258     {
 259         udata->LVColumnWidth[i] = 0;
 260     }
 261
 262     ForeachNode(&udata->ListviewList, node)
 263     {
 264         for(i = 0; i < ASLLV_MAXCOLUMNS; i++)
 265         {
 266             WORD w;
 267
 268             if (node->text[i])
 269             {
 270                 w = TextLength(&ld->ld_DummyRP, node->text[i], strlen(node->text[i]));
 271                 if (w > udata->LVColumnWidth[i]) udata->LVColumnWidth[i] = w;
 272             }
 273         }
 274     }
 275
 276     if (udata->LVColumnWidth[0] < FREQ_MIN_FILECOLUMNWIDTH)
 277     {
 278         udata->LVColumnWidth[0] = FREQ_MIN_FILECOLUMNWIDTH;
 279     }
 280 }
 281
 282
 283 /*****************************************************************************************/
 284
 285 static WORD FRCompareDirectoryNodes(struct IntFileReq *ifreq, struct ASLLVFileReqNode *node1,
 286                                     struct ASLLVFileReqNode *node2, struct AslBase_intern *AslBase)
 287 {
 288     WORD pri1 = (node1->subtype > 0) ? 1 : 0;
 289     WORD pri2 = (node2->subtype > 0) ? 1 : 0;
 290     WORD diff = (pri2 - pri1) * -(ifreq->ifr_SortDrawers - 1);
 291     LONG bigdiff;
 292
 293     if (!diff)
 294     {
 295         switch(ifreq->ifr_SortBy)
 296         {
 297             case ASLFRSORTBY_Name:
 298                 diff = Stricmp(node1->node.ln_Name, node2->node.ln_Name);
 299                 break;
 300
 301             case ASLFRSORTBY_Date:
 302                 bigdiff = CompareDates((const struct DateStamp *)&node2->date, (const struct DateStamp *)&node1->date);
 303                 if (bigdiff < 0)
 304                 {
 305                     diff = -1;
 306                 } else if (bigdiff > 0)
 307                 {
 308                     diff = 1;
 309                 }
 310                 break;
 311
 312             case ASLFRSORTBY_Size:
 313                 if (node1->filesize < node2->filesize)
 314                 {
 315                     diff = -1;
 316                 }
 317                 else if (node1->filesize > node2->filesize)
 318                 {
 319                     diff = 1;
 320                 }
 321                 break;
 322         }
 323
 324         if (ifreq->ifr_SortOrder == ASLFRSORTORDER_Descend) diff = -diff;
 325     }
 326
 327     return diff;
 328 }
 329
 330 BOOL FRGetDirectory(STRPTR path, struct LayoutData *ld, struct AslBase_intern *AslBase)
 331 {
 332     struct FRUserData           *udata = (struct FRUserData *)ld->ld_UserData;
 333     struct IntFileReq           *ifreq = (struct IntFileReq *)ld->ld_IntReq;
 334     struct FileRequester        *freq = (struct FileRequester *)ld->ld_Req;
 335     struct FileInfoBlock        *fib;
 336     UBYTE                       parsedpattern[MAX_PATTERN_LEN * 2 + 3];
 337     BPTR                        lock;
 338     BOOL                        dopatternstring = FALSE, success = FALSE;
 339
 340     FRDirectoryScanSymbolState(ld, TRUE, AslBase);
 341
 342     FRFreeListviewList(ld, AslBase);
 343     FRMultiSelectOnOff(ld, (ifreq->ifr_Flags1 & FRF_DOMULTISELECT) ? TRUE : FALSE, AslBase);
 344
 345     if (ifreq->ifr_Flags1 & FRF_DOPATTERNS)
 346     {
 347         char *pat;
 348
 349         GetAttr(STRINGA_TextVal, udata->PatternGad, (IPTR *)&pat);
 350         if (pat[0])
 351         {
 352             if (ParsePatternNoCase(pat, parsedpattern, MAX_PATTERN_LEN * 2 + 3) != -1)
 353             {
 354                 dopatternstring = TRUE;
 355             }
 356         }
 357     }
 358
 359     lock = Lock(path, ACCESS_READ);
 360     if (!lock)
 361     {
 362         D(bug("Could not lock directory \"%s\"\n", path));
 363     }
 364     else
 365     {
 366         fib = AllocDosObject(DOS_FIB, NULL);
 367         if (fib)
 368         {
 369             success = Examine(lock, fib);
 370
 371             if (success && fib->fib_DirEntryType > 0) for(;;)
 372             {
 373                 struct ASLLVFileReqNode *node;
 374                 BOOL                    ok, addentry = TRUE;
 375
 376                 ok = ExNext(lock, fib);
 377
 378                 if (!ok)
 379                 {
 380                     if (IoErr() == ERROR_NO_MORE_ENTRIES) break;
 381                     success = FALSE;
 382                     continue;
 383                 }
 384
 385                 /* add to list checks which affect only files */
 386
 387                 if (fib->fib_DirEntryType < 0)
 388                 {
 389                     if (ifreq->ifr_Flags2 & FRF_DRAWERSONLY) addentry = FALSE;
 390
 391                     if (addentry && (ifreq->ifr_Flags2 & FRF_REJECTICONS))
 392                     {
 393                         WORD len = strlen(fib->fib_FileName);
 394                         if (len >= 5)
 395                         {
 396                             if (Stricmp(fib->fib_FileName + len - 5, ".info") == 0) addentry = FALSE;
 397                         }
 398                     }
 399
 400                     if (addentry && dopatternstring)
 401                     {
 402                         if (!MatchPatternNoCase(parsedpattern, fib->fib_FileName)) addentry = FALSE;
 403                     }
 404
 405                     if (addentry && ifreq->ifr_AcceptPattern)
 406                     {
 407                         if (!MatchPatternNoCase(ifreq->ifr_AcceptPattern, fib->fib_FileName)) addentry = FALSE;
 408                     }
 409
 410                     if (addentry && ifreq->ifr_RejectPattern)
 411                     {
 412                         if (MatchPatternNoCase(ifreq->ifr_RejectPattern, fib->fib_FileName)) addentry = FALSE;
 413                     }
 414
 415                 } /* if (fib->fib_DirEntryType < 0) */
 416
 417                 /* add to list checks which affect both files and drawers */
 418
 419                 if (addentry && ifreq->ifr_HookFunc && (ifreq->ifr_Flags1 & FRF_FILTERFUNC))
 420                 {
 421                     struct AnchorPath ap;
 422                     STRPTR            old_frdrawer;
 423
 424                     /* FIXME: is ap.ap_Info enough for the hookfunc */
 425
 426                     memset(&ap, 0, sizeof(ap));
 427                     ap.ap_Info = *fib;
 428
 429                     /* Some user filter functions access freq->fr_Drawer :-( */
 430
 431                     old_frdrawer = freq->fr_Drawer;
 432                     freq->fr_Drawer = path;
 433
 434                     D(bug("FRGetDirectory: 1 fr_Drawer 0x%lx <%s>\n",path,path));
 435
 436                     /* return code 0 means, add to list */
 437
 438 #ifdef __MORPHOS__
 439                     {
 440                         ULONG ret;
 441                         UWORD *funcptr = ifreq->ifr_HookFunc;
 442                         ULONG *p = (ULONG *)REG_A7 - 3;
 443
 444                         p[0] = (ULONG)FRF_FILTERFUNC;
 445                         p[1] = (ULONG)&ap;
 446                         p[2] = (ULONG)freq;
 447                         REG_A7 = (ULONG)p;
 448
 449                         if (*funcptr >= (UWORD)0xFF00)
 450                             REG_A7 -= 4;
 451
 452                         REG_A4 = (ULONG)ifreq->ifr_IntReq.ir_BasePtr;   /* Compatability */
 453
 454                         ret = (ULONG)(*MyEmulHandle->EmulCallDirect68k)(funcptr);
 455
 456                         if (*funcptr >= (UWORD)0xFF00)
 457                             REG_A7 += 4;
 458
 459                         REG_A7 += (3*4);
 460
 461                         if (ret != 0)
 462                             addentry = FALSE;
 463                     }
 464 #else
 465                     if (ifreq->ifr_HookFunc(FRF_FILTERFUNC, &ap, freq) != 0)
 466                         addentry = FALSE;
 467 #endif
 468
 469                     freq->fr_Drawer = old_frdrawer;
 470                 }
 471
 472                 if (addentry && ifreq->ifr_FilterFunc)
 473                 {
 474                     struct AnchorPath ap;
 475                     STRPTR            old_frdrawer;
 476
 477                     /* FIXME: is ap.ap_Info enough for the filterfunc */
 478
 479                     memset(&ap, 0, sizeof(ap));
 480                     ap.ap_Info = *fib;
 481
 482                     /* Some user filter functions access freq->fr_Drawer :-( */
 483
 484                     old_frdrawer = freq->fr_Drawer;
 485                     freq->fr_Drawer = path;
 486
 487                     D(bug("FRGetDirectory: 2 fr_Drawer 0x%lx <%s>\n",path,path));
 488
 489                     /* return code TRUE (!= 0) means, add to list */
 490
 491 #ifdef __MORPHOS__
 492                     {
 493                         ULONG ret;
 494
 495                         REG_A4 = (ULONG)ifreq->ifr_IntReq.ir_BasePtr;   /* Compatability */
 496                         REG_A0 = (ULONG)ifreq->ifr_FilterFunc;
 497                         REG_A2 = (ULONG)freq;
 498                         REG_A1 = (ULONG)&ap;
 499                         ret = (*MyEmulHandle->EmulCallDirect68k)(ifreq->ifr_FilterFunc->h_Entry);
 500
 501                         if (ret == 0)
 502                             addentry = FALSE;
 503                     }
 504 #else
 505                     if (CallHookPkt(ifreq->ifr_FilterFunc, freq, &ap) == 0)
 506                         addentry = FALSE;
 507 #endif
 508
 509                     freq->fr_Drawer = old_frdrawer;
 510
 511                     D(bug("FRGetDirectory: 3 fr_Drawer 0x%lx <%s>\n",old_frdrawer,old_frdrawer));
 512
 513                 }
 514
 515                 if (addentry)
 516                 {
 517                     if ((node = AllocPooled(ld->ld_IntReq->ir_MemPool, sizeof(struct ASLLVFileReqNode))))
 518                     {
 519                         struct DateTime dt;
 520                         char            datebuffer[LEN_DATSTRING];
 521                         char            timebuffer[LEN_DATSTRING];
 522
 523                         if (fib->fib_FileName[0])
 524                         {
 525                             node->text[0] = node->node.ln_Name = PooledCloneString(fib->fib_FileName,
 526                                                                                    NULL,
 527                                                                                    ld->ld_IntReq->ir_MemPool,
 528                                                                                    AslBase);
 529                         }
 530
 531                         if (fib->fib_DirEntryType > 0)
 532                         {
 533                             node->text[1] = GetString(MSG_FILEREQ_LV_DRAWER, GetIR(ifreq)->ir_Catalog, AslBase);
 534                             node->dontfreetext |= (1 << 1);
 535                         } else {
 536                             node->text[1] = PooledUIntegerToString(fib->fib_Size,
 537                                                                   ld->ld_IntReq->ir_MemPool,
 538                                                                   AslBase);
 539
 540                             MARK_DO_MULTISEL(node);
 541                         }
 542
 543                         dt.dat_Stamp = fib->fib_Date;
 544                         dt.dat_Format = FORMAT_DOS;
 545                         dt.dat_Flags = 0;
 546                         dt.dat_StrDay = NULL;
 547                         dt.dat_StrDate = datebuffer;
 548                         dt.dat_StrTime = timebuffer;
 549
 550                         if (DateToStr(&dt))
 551                         {
 552                             //sprintf(datebuffer, "%x8", fib->fib_Date.ds_Days);
 553                             //sprintf(timebuffer, "%x8", fib->fib_Date.ds_Minute);
 554
 555                             node->text[2] = PooledCloneString(datebuffer, NULL, ld->ld_IntReq->ir_MemPool, AslBase);
 556                             node->text[3] = PooledCloneString(timebuffer, NULL, ld->ld_IntReq->ir_MemPool, AslBase);
 557                         }
 558
 559                         if (fib->fib_Comment[0])
 560                         {
 561                             node->text[4] = PooledCloneString(fib->fib_Comment, NULL, ld->ld_IntReq->ir_MemPool, AslBase);
 562                         }
 563
 564                         node->userdata = ld;
 565                         node->date     = fib->fib_Date;
 566                         node->filesize = fib->fib_Size;
 567                         node->type     = ASLLV_FRNTYPE_DIRECTORY;
 568                         node->subtype  = fib->fib_DirEntryType;
 569
 570                         SortInNode(ifreq, &udata->ListviewList, &node->node, (APTR)FRCompareDirectoryNodes, AslBase);
 571                     }
 572
 573                 } /* if (addentry) */
 574
 575             } /* foreach file in directory */
 576
 577             FreeDosObject(DOS_FIB, fib);
 578
 579         } /* if (DosObject allocated) */
 580
 581         UnLock(lock);
 582
 583     } /* if (directory locked) */
 584
 585     udata->LVColumnAlign[0] = ASLLV_ALIGN_LEFT;         /* File/Dir name */
 586     udata->LVColumnAlign[1] = ASLLV_ALIGN_RIGHT;        /* Size/"Drawer" */
 587     udata->LVColumnAlign[2] = ASLLV_ALIGN_LEFT;         /* Date */
 588     udata->LVColumnAlign[3] = ASLLV_ALIGN_LEFT;         /* Time */
 589     udata->LVColumnAlign[4] = ASLLV_ALIGN_LEFT;         /* Comment */
 590
 591     FRCalcColumnWidths(ld, AslBase);
 592     FRRefreshListview(ld, AslBase);
 593
 594     udata->Flags &= ~FRFLG_SHOWING_VOLUMES;
 595
 596     FRDirectoryScanSymbolState(ld, FALSE, AslBase);
 597
 598     return success;
 599 }
 600
 601 /*****************************************************************************************/
 602
 603 static WORD FRCompareVolumeNodes(struct IntFileReq *ifreq, struct ASLLVFileReqNode *node1,
 604                                  struct ASLLVFileReqNode *node2, struct AslBase_intern *AslBase)
 605 {
 606     WORD pri1, pri2, diff;
 607
 608     switch(node1->subtype)
 609     {
 610         case DLT_DIRECTORY:
 611         case DLT_LATE:
 612         case DLT_NONBINDING:
 613             pri1 = 0;
 614             break;
 615
 616         default:
 617             pri1 = 1;
 618             break;
 619     }
 620
 621     switch(node2->subtype)
 622     {
 623         case DLT_DIRECTORY:
 624         case DLT_LATE:
 625         case DLT_NONBINDING:
 626             pri2 = 0;
 627             break;
 628
 629         default:
 630             pri2 = 1;
 631             break;
 632     }
 633
 634     diff = pri2 - pri1;
 635     if (!diff) diff = Stricmp(node1->node.ln_Name, node2->node.ln_Name);
 636
 637     return diff;
 638 }
 639
 640 /*****************************************************************************************/
 641
 642 BOOL FRGetVolumes(struct LayoutData *ld, struct AslBase_intern *AslBase)
 643 {
 644     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
 645     struct IntFileReq   *ifreq = (struct IntFileReq *)ld->ld_IntReq;
 646     struct DosList      *dlist;
 647     BOOL                success = TRUE;
 648
 649     FRDirectoryScanSymbolState(ld, TRUE, AslBase);
 650
 651     FRFreeListviewList(ld, AslBase);
 652     FRMultiSelectOnOff(ld, FALSE, AslBase);
 653
 654     dlist = LockDosList(LDF_READ | LDF_VOLUMES | LDF_ASSIGNS);
 655
 656     while ((dlist = NextDosEntry(dlist, LDF_VOLUMES | LDF_ASSIGNS)) != NULL)
 657     {
 658         struct ASLLVFileReqNode *node;
 659
 660         if ((node = AllocPooled(ld->ld_IntReq->ir_MemPool, sizeof(struct ASLLVFileReqNode))))
 661         {
 662 #ifdef __MORPHOS__
 663             char *name = BADDR(dlist->dol_Name);
 664             if (name)
 665             {
 666                 node->text[0] = PooledCloneStringLen(&name[1], name[0], ":", sizeof(":"), ld->ld_IntReq->ir_MemPool, AslBase);
 667                 node->node.ln_Name = PooledCloneStringLen(&name[1], name[0], NULL, 0, ld->ld_IntReq->ir_MemPool, AslBase);
 668             }
 669 #else
 670             char *name = dlist->dol_Ext.dol_AROS.dol_DevName;
 671             if (name)
 672             {
 673                 node->text[0] = node->node.ln_Name = PooledCloneString(name, ":", ld->ld_IntReq->ir_MemPool, AslBase);
 674             }
 675 #endif
 676
 677             switch(dlist->dol_Type)
 678             {
 679                 case DLT_DIRECTORY:
 680                 case DLT_LATE:
 681                 case DLT_NONBINDING:
 682                     node->text[1] = GetString(MSG_FILEREQ_LV_ASSIGN, GetIR(ifreq)->ir_Catalog, AslBase);
 683                     node->dontfreetext |= (1 << 1);
 684                     break;
 685
 686 #ifdef __MORPHOS__
 687                 case DLT_VOLUME:
 688                     {
 689                         struct DosList *dl = LockDosList(LDF_DEVICES | LDF_READ);
 690
 691                         while ((dl = NextDosEntry(dl, LDF_DEVICES)))
 692                         {
 693                             /* This works for most filesystems */
 694                             if (dl->dol_Task == dlist->dol_Task)
 695                             {
 696                                 STRPTR devname = (STRPTR)BADDR(dl->dol_Name);
 697                                 ULONG devlen = *devname++;
 698
 699                                 if (devname[devlen-1] == 0) devlen--;
 700
 701                                 node->text[1] = AllocPooled(ld->ld_IntReq->ir_MemPool, devlen + 3);
 702                                 node->text[1][0] = '(';
 703                                 strncpy(&node->text[1][1], devname, devlen);
 704                                 node->text[1][devlen+1] = ')';
 705                                 node->text[1][devlen+2] = 0;
 706
 707                                 break;
 708                             }
 709                         }
 710
 711                         UnLockDosList(LDF_DEVICES | LDF_READ);
 712                     }
 713                     break;
 714 #endif
 715             }
 716
 717             node->userdata = ld;
 718
 719             node->filesize    = 0;
 720             node->type        = ASLLV_FRNTYPE_VOLUMES;
 721             node->subtype     = dlist->dol_Type;
 722
 723             SortInNode(ifreq, &udata->ListviewList, &node->node, (APTR)FRCompareVolumeNodes, AslBase);
 724
 725         }
 726
 727     }
 728
 729     UnLockDosList(LDF_READ | LDF_VOLUMES | LDF_ASSIGNS);
 730
 731     udata->LVColumnAlign[0] = ASLLV_ALIGN_LEFT;
 732     udata->LVColumnAlign[1] = ASLLV_ALIGN_RIGHT;
 733
 734     FRCalcColumnWidths(ld, AslBase);
 735     FRRefreshListview(ld, AslBase);
 736
 737     udata->Flags |= FRFLG_SHOWING_VOLUMES;
 738
 739     FRDirectoryScanSymbolState(ld, FALSE, AslBase);
 740
 741     return success;
 742 }
 743
 744 /*****************************************************************************************/
 745
 746 void FRSetPath(STRPTR path, struct LayoutData *ld, struct AslBase_intern *AslBase)
 747 {
 748     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
 749     struct TagItem      set_tags[] =
 750     {
 751         {STRINGA_TextVal        , path ? (IPTR)path : (IPTR)""  },
 752         {TAG_DONE                                               }
 753     };
 754
 755     SetGadgetAttrsA((struct Gadget *)udata->PathGad, ld->ld_Window, NULL, set_tags);
 756 }
 757
 758 /*****************************************************************************************/
 759
 760 BOOL FRNewPath(STRPTR path, struct LayoutData *ld, struct AslBase_intern *AslBase)
 761 {
 762     char                pathstring[MAX_PATH_LEN];
 763     BOOL                result = FALSE;
 764
 765     strcpy(pathstring, path);
 766     fixpath(pathstring);
 767
 768     FRSetPath(pathstring, ld, AslBase);
 769
 770     result = FRGetDirectory(pathstring, ld, AslBase);
 771
 772     return result;
 773 }
 774
 775 /*****************************************************************************************/
 776
 777 BOOL FRAddPath(STRPTR path, struct LayoutData *ld, struct AslBase_intern *AslBase)
 778 {
 779     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
 780     char                pathstring[MAX_PATH_LEN], *gadpath;
 781     BOOL                result;
 782
 783     GetAttr(STRINGA_TextVal, udata->PathGad, (IPTR *)&gadpath);
 784
 785     strcpy(pathstring, gadpath);
 786     AddPart(pathstring, path, MAX_PATH_LEN);
 787
 788     result = FRNewPath(pathstring, ld, AslBase);
 789
 790     return result;
 791
 792 }
 793
 794 /*****************************************************************************************/
 795
 796 BOOL FRParentPath(struct LayoutData *ld, struct AslBase_intern *AslBase)
 797 {
 798     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
 799     char                pathstring[MAX_PATH_LEN], *gadpath;
 800     WORD                len;
 801     BOOL                result;
 802
 803     GetAttr(STRINGA_TextVal, udata->PathGad, (IPTR *)&gadpath);
 804
 805     strcpy(pathstring, gadpath);
 806     fixpath(pathstring);
 807
 808     len = strlen(pathstring);
 809     if (len == 0)
 810     {
 811         strcpy(pathstring, "/");
 812     }
 813     else if (len < MAX_PATH_LEN - 3)
 814     {
 815         switch(pathstring[len - 1])
 816         {
 817             case '/':
 818             case ':':
 819                 strcat(pathstring, "/");
 820                 break;
 821
 822             default:
 823                 strcat(pathstring, "//");
 824                 fixpath(pathstring);
 825                 break;
 826         }
 827     }
 828
 829     result = FRNewPath(pathstring, ld, AslBase);
 830
 831     return result;
 832
 833 }
 834
 835 /*****************************************************************************************/
 836
 837 void FRSetFile(STRPTR file, struct LayoutData *ld, struct AslBase_intern *AslBase)
 838 {
 839     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
 840     struct TagItem      set_tags[] =
 841     {
 842         {STRINGA_TextVal        , file ? (IPTR)file : (IPTR)""  },
 843         {TAG_DONE                                               }
 844     };
 845
 846     SetGadgetAttrsA((struct Gadget *)udata->FileGad, ld->ld_Window, NULL, set_tags);
 847 }
 848
 849 /*****************************************************************************************/
 850
 851 void FRChangeActiveLVItem(struct LayoutData *ld, WORD delta, UWORD quali, struct Gadget *gad, struct AslBase_intern *AslBase)
 852 {
 853     struct FRUserData           *udata = (struct FRUserData *)ld->ld_UserData;
 854     struct IntFileReq           *ifreq = (struct IntFileReq *)ld->ld_IntReq;
 855     struct ASLLVFileReqNode     *node;
 856     IPTR                        active, total, visible;
 857     struct Gadget               *mainstrgad;
 858     struct TagItem              set_tags[] =
 859     {
 860         {ASLLV_Active           , 0             },
 861         {ASLLV_MakeVisible      , 0             },
 862         {TAG_DONE                               }
 863     };
 864
 865     GetAttr(ASLLV_Active , udata->Listview, &active );
 866     GetAttr(ASLLV_Total  , udata->Listview, &total  );
 867     GetAttr(ASLLV_Visible, udata->Listview, &visible);
 868
 869     mainstrgad = (struct Gadget *)((ifreq->ifr_Flags2 & FRF_DRAWERSONLY) ? udata->PathGad : udata->FileGad);
 870
 871     if (total < 1) return;
 872
 873     if (quali & (IEQUALIFIER_LSHIFT | IEQUALIFIER_RSHIFT))
 874     {
 875         delta *= (visible - 1);
 876     }
 877     else if (quali & (IEQUALIFIER_LALT | IEQUALIFIER_RALT | IEQUALIFIER_CONTROL))
 878     {
 879         delta *= total;
 880     }
 881     else if (gad && (gad == mainstrgad))
 882     {
 883         /* try to jump to first item which matches text in string gadget,
 884            but only if text in string gadget mismatches actual active
 885            item's text (in this case move normally = one step)) */
 886
 887         char buffer[MAX_FILE_LEN];
 888         char *val;
 889         WORD i, len;
 890         BOOL dojump = TRUE;
 891
 892         GetAttr(STRINGA_TextVal, (Object *)gad, (IPTR *)&val);
 893         strcpy(buffer, val);
 894
 895         len = strlen(buffer);
 896         if (len > 0) if (buffer[len - 1] == '/') buffer[--len] = '\0';
 897
 898         if (len)
 899         {
 900             if (((LONG)active) >= 0)
 901             {
 902                 if ((node = (struct ASLLVFileReqNode *)FindListNode(&udata->ListviewList, (WORD)active)))
 903                 {
 904                     if (stricmp(node->node.ln_Name, buffer) == 0) dojump = FALSE;
 905                 }
 906             }
 907
 908             if (dojump)
 909             {
 910                 i = 0;
 911                 ForeachNode(&udata->ListviewList, node)
 912                 {
 913                     if (Strnicmp((CONST_STRPTR)node->node.ln_Name, (CONST_STRPTR)buffer, len) == 0)
 914                     {
 915                         active = i;
 916                         delta = 0;
 917                         break;
 918                     }
 919                     i++;
 920
 921                 }
 922
 923             } /* if (dojump) */
 924
 925         } /* if (len) */
 926
 927     }
 928
 929     active += delta;
 930
 931     if (((LONG)active) < 0) active = 0;
 932     if (active >= total) active = total - 1;
 933
 934     set_tags[0].ti_Data = set_tags[1].ti_Data = active;
 935
 936     SetGadgetAttrsA((struct Gadget *)udata->Listview, ld->ld_Window, NULL, set_tags);
 937
 938     if ((node = (struct ASLLVFileReqNode *)FindListNode(&udata->ListviewList, (WORD)active)))
 939     {
 940         if (ifreq->ifr_Flags2 & FRF_DRAWERSONLY)
 941         {
 942             FRSetPath(node->node.ln_Name, ld, AslBase);
 943         } else {
 944             char pathstring[MAX_FILE_LEN];
 945
 946             strcpy(pathstring, node->node.ln_Name);
 947             if ((node->subtype > 0) && (!(udata->Flags & FRFLG_SHOWING_VOLUMES)))
 948             {
 949                 strcat(pathstring, "/");
 950             }
 951
 952             FRSetFile(pathstring, ld, AslBase);
 953         }
 954     }
 955
 956     if (gad)
 957     {
 958         ActivateGadget(gad, ld->ld_Window, NULL);
 959     } else {
 960         FRActivateMainStringGadget(ld, AslBase);
 961     }
 962 }
 963
 964 /*****************************************************************************************/
 965
 966 void FRActivateMainStringGadget(struct LayoutData *ld, struct AslBase_intern *AslBase)
 967 {
 968     struct FRUserData *udata = (struct FRUserData *)ld->ld_UserData;
 969     struct IntFileReq *ifreq = (struct IntFileReq *)ld->ld_IntReq;
 970
 971     if (ifreq->ifr_Flags2 & FRF_DRAWERSONLY)
 972     {
 973         ActivateGadget((struct Gadget *)udata->PathGad, ld->ld_Window, NULL);
 974     } else {
 975         ActivateGadget((struct Gadget *)udata->FileGad, ld->ld_Window, NULL);
 976     }
 977 }
 978
 979 /*****************************************************************************************/
 980
 981 void FRMultiSelectOnOff(struct LayoutData *ld, BOOL onoff, struct AslBase_intern *AslBase)
 982 {
 983     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
 984     struct TagItem      set_tags[] =
 985     {
 986         {ASLLV_DoMultiSelect    , onoff },
 987         {TAG_DONE                       }
 988     };
 989
 990     SetGadgetAttrsA((struct Gadget *)udata->Listview, ld->ld_Window, NULL, set_tags);
 991 }
 992
 993 /*****************************************************************************************/
 994
 995 void FRSetPattern(STRPTR pattern, struct LayoutData *ld, struct AslBase_intern *AslBase)
 996 {
 997     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
 998     struct TagItem      set_tags[] =
 999     {
1000         {STRINGA_TextVal        , pattern ? (IPTR)pattern : (IPTR)""    },
1001         {TAG_DONE                                                       }
1002     };
1003
1004     SetGadgetAttrsA((struct Gadget *)udata->PatternGad, ld->ld_Window, NULL, set_tags);
1005 }
1006
1007 /*****************************************************************************************/
1008
1009 void FRSelectRequester(struct LayoutData *ld, struct AslBase_intern *AslBase)
1010 {
1011     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
1012     struct IntFileReq   *ifreq = (struct IntFileReq *)ld->ld_IntReq;
1013     STRPTR              oldpattern = udata->SelectPattern;
1014
1015     udata->SelectPattern = REQ_String(GetString(MSG_FILEREQ_SELECT_TITLE, GetIR(ifreq)->ir_Catalog, AslBase),
1016                                       oldpattern ? oldpattern : (STRPTR)"#?",
1017                                       GetString(MSG_FILEREQ_SELECT_OK, GetIR(ifreq)->ir_Catalog, AslBase),
1018                                       GetString(MSG_FILEREQ_SELECT_CANCEL, GetIR(ifreq)->ir_Catalog, AslBase),
1019                                       ld,
1020                                       AslBase);
1021
1022     if (oldpattern) MyFreeVecPooled(oldpattern, AslBase);
1023
1024     if (udata->SelectPattern)
1025     {
1026         LONG patternlen = strlen(udata->SelectPattern);
1027
1028         if (patternlen > 0)
1029         {
1030             STRPTR parsedpattern;
1031
1032             parsedpattern = MyAllocVecPooled(ld->ld_IntReq->ir_MemPool, patternlen * 2 + 3, AslBase);
1033             if (parsedpattern)
1034             {
1035                 if (ParsePatternNoCase(udata->SelectPattern, parsedpattern, patternlen * 2 + 3) != -1)
1036                 {
1037                     struct ASLLVFileReqNode *node;
1038
1039                     if (udata->Flags & FRFLG_SHOWING_VOLUMES)
1040                     {
1041                         UBYTE *dir;
1042
1043                         GetAttr(STRINGA_TextVal, udata->PathGad, (IPTR *)&dir);
1044                         FRGetDirectory(dir, ld, AslBase);
1045                     }
1046
1047                     SetGadgetAttrs((struct Gadget *)udata->Listview, ld->ld_Window, NULL, ASLLV_Active, -1,
1048                                                                                           TAG_DONE);
1049
1050                     ForeachNode(&udata->ListviewList, node)
1051                     {
1052                         if (IS_MULTISEL(node) && node->node.ln_Name)
1053                         {
1054                             if (MatchPatternNoCase(parsedpattern, node->node.ln_Name))
1055                             {
1056                                 MARK_SELECTED(node);
1057                             } else {
1058                                 MARK_UNSELECTED(node);
1059                             }
1060                         }
1061                     }
1062
1063                     RefreshGList((struct Gadget *)udata->Listview, ld->ld_Window, NULL, 1);
1064
1065                 }
1066                 MyFreeVecPooled(parsedpattern, AslBase);
1067
1068             } /* if (parsedpattern) */
1069
1070         } /* if (udata->SelectPattern[0]) */
1071
1072     } /* if (udata->SelectPattern) */
1073
1074 } /**/
1075
1076 /*****************************************************************************************/
1077
1078 void FRDeleteRequester(struct LayoutData *ld, struct AslBase_intern *AslBase)
1079 {
1080     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
1081     struct IntFileReq   *ifreq = (struct IntFileReq *)ld->ld_IntReq;
1082     STRPTR              name = NULL, name2, s;
1083
1084     GetAttr(STRINGA_TextVal, udata->PathGad, (IPTR *)&name);
1085
1086     if (ifreq->ifr_Flags2 & FRF_DRAWERSONLY)
1087     {
1088         name = name2 = VecPooledCloneString(name, NULL, ld->ld_IntReq->ir_MemPool, AslBase);
1089     } else {
1090         GetAttr(STRINGA_TextVal, udata->FileGad, (IPTR *)&name2);
1091
1092         if ((s = MyAllocVecPooled(ld->ld_IntReq->ir_MemPool, strlen(name) + strlen(name2) + 4, AslBase)))
1093         {
1094             strcpy(s, name);
1095             AddPart(s, name2, 10000);
1096             name = s;
1097         }
1098     }
1099
1100     if (name) if (name[0])
1101     {
1102         struct EasyStruct es;
1103
1104         es.es_StructSize   = sizeof(es);
1105         es.es_Flags        = 0;
1106         es.es_Title        = GetString(MSG_FILEREQ_DELETE_TITLE   , GetIR(ifreq)->ir_Catalog, AslBase);
1107         es.es_TextFormat   = GetString(MSG_FILEREQ_DELETE_MSG     , GetIR(ifreq)->ir_Catalog, AslBase);
1108         es.es_GadgetFormat = GetString(MSG_FILEREQ_DELETE_OKCANCEL, GetIR(ifreq)->ir_Catalog, AslBase);
1109
1110         if (EasyRequestArgs(ld->ld_Window, &es, NULL, &name) == 1)
1111         {
1112             if (DeleteFile(name) && !(udata->Flags & FRFLG_SHOWING_VOLUMES))
1113             {
1114                 struct ASLLVFileReqNode *node;
1115                 struct TagItem          set_tags[] =
1116                 {
1117                     {ASLLV_Labels       , 0     },
1118                     {ASLLV_Top          , 0     },
1119                     {TAG_DONE                   }
1120                 };
1121                 IPTR                    top;
1122
1123                 GetAttr(ASLLV_Top, udata->Listview, &top);
1124                 SetGadgetAttrsA((struct Gadget *)udata->Listview, ld->ld_Window, NULL, set_tags);
1125
1126                 ForeachNode(&udata->ListviewList, node)
1127                 {
1128                     if (node->node.ln_Name)
1129                     {
1130                         if (stricmp(node->node.ln_Name, name2) == 0)
1131                         {
1132                             Remove(&node->node);
1133                             FRFreeListviewNode(node, ld, AslBase);
1134                             break;
1135                         }
1136                     }
1137                 }
1138
1139                 set_tags[0].ti_Data = (IPTR)&udata->ListviewList;
1140                 set_tags[1].ti_Data = top;
1141                 SetGadgetAttrsA((struct Gadget *)udata->Listview, ld->ld_Window, NULL, set_tags);
1142
1143
1144             } /* if (DeleteFile(name) && !(udata->Flags & FRFLG_SHOWING_VOLUMES)) */
1145
1146         } /* if (EasyRequestArgs(ld->ld_Window, &es, NULL, &name) == 1) */
1147
1148     } /* if (name) if (name[0]) */
1149
1150     if (name) MyFreeVecPooled(name, AslBase);
1151 }
1152
1153 /*****************************************************************************************/
1154
1155 void FRNewDrawerRequester(struct LayoutData *ld, struct AslBase_intern *AslBase)
1156 {
1157     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
1158     struct IntFileReq   *ifreq = (struct IntFileReq *)ld->ld_IntReq;
1159     STRPTR              path, dirname;
1160     BPTR                lock, lock2, olddir;
1161
1162     GetAttr(STRINGA_TextVal, udata->PathGad, (IPTR *)&path);
1163
1164     lock = Lock(path, SHARED_LOCK);
1165     if (lock)
1166     {
1167         olddir = CurrentDir(lock);
1168
1169         if ((dirname = REQ_String(GetString(MSG_FILEREQ_CREATEDRAWER_TITLE, GetIR(ifreq)->ir_Catalog, AslBase),
1170                                   GetString(MSG_FILEREQ_CREATEDRAWER_DEFNAME, GetIR(ifreq)->ir_Catalog, AslBase),
1171                                   GetString(MSG_FILEREQ_CREATEDRAWER_OK, GetIR(ifreq)->ir_Catalog, AslBase),
1172                                   GetString(MSG_FILEREQ_CREATEDRAWER_CANCEL, GetIR(ifreq)->ir_Catalog, AslBase),
1173                                   ld,
1174                                   AslBase)))
1175         {
1176             if ((lock2 = CreateDir(dirname)))
1177             {
1178                 if (!(udata->Flags & FRFLG_SHOWING_VOLUMES))
1179                 {
1180                     struct TagItem      set_tags[] =
1181                     {
1182                         {ASLLV_Top      , 0     },
1183                         {TAG_DONE               }
1184                     };
1185                     IPTR                top;
1186
1187                     GetAttr(ASLLV_Top, udata->Listview, &top);
1188
1189                     FRGetDirectory(path, ld, AslBase);
1190
1191                     set_tags[0].ti_Data = top;
1192                     SetGadgetAttrsA((struct Gadget *)udata->Listview, ld->ld_Window, NULL, set_tags);
1193                 }
1194
1195                 UnLock(lock2);
1196
1197             } /* if ((lock2 = CreateDir(dirname))) */
1198
1199             MyFreeVecPooled(dirname, AslBase);
1200
1201         }; /* if ((dirname = REQ_String(... */
1202
1203         CurrentDir(olddir);
1204         UnLock(lock);
1205
1206     } /* if (lock) */
1207
1208 }
1209
1210 /*****************************************************************************************/
1211
1212 void FRRenameRequester(struct LayoutData *ld, struct AslBase_intern *AslBase)
1213 {
1214     struct FRUserData   *udata = (struct FRUserData *)ld->ld_UserData;
1215     struct IntFileReq   *ifreq = (struct IntFileReq *)ld->ld_IntReq;
1216     STRPTR              path, file, newname;
1217     BPTR                lock, lock2, olddir;
1218
1219     if (ifreq->ifr_Flags2 & FRF_DRAWERSONLY) return;
1220
1221     GetAttr(STRINGA_TextVal, udata->FileGad, (IPTR *)&file);
1222     if (!file[0]) return;
1223
1224     GetAttr(STRINGA_TextVal, udata->PathGad, (IPTR *)&path);
1225
1226     lock = Lock(path, SHARED_LOCK);
1227     if (lock)
1228     {
1229         olddir = CurrentDir(lock);
1230
1231         lock2 = Lock(file, SHARED_LOCK);
1232         if (lock2)
1233         {
1234             UnLock(lock2);
1235
1236             if ((newname = REQ_String(GetString(MSG_FILEREQ_RENAME_TITLE, GetIR(ifreq)->ir_Catalog, AslBase),
1237                                       file,
1238                                       GetString(MSG_FILEREQ_RENAME_OK, GetIR(ifreq)->ir_Catalog, AslBase),
1239                                       GetString(MSG_FILEREQ_RENAME_CANCEL, GetIR(ifreq)->ir_Catalog, AslBase),
1240                                       ld,
1241                                       AslBase)))
1242             {
1243                 if (Rename(file, newname))
1244                 {
1245                     FRSetFile(newname, ld, AslBase);
1246
1247                     if (!(udata->Flags & FRFLG_SHOWING_VOLUMES))
1248                     {
1249                         struct TagItem  set_tags[] =
1250                         {
1251                             {ASLLV_Top  , 0     },
1252                             {TAG_DONE           }
1253                         };
1254                         IPTR            top;
1255
1256                         GetAttr(ASLLV_Top, udata->Listview, &top);
1257
1258                         FRGetDirectory(path, ld, AslBase);
1259
1260                         set_tags[0].ti_Data = top;
1261                         SetGadgetAttrsA((struct Gadget *)udata->Listview, ld->ld_Window, NULL, set_tags);
1262                     }
1263
1264                 } /* if (Rename(file, newname)) */
1265
1266                 MyFreeVecPooled(newname, AslBase);
1267
1268             }; /* if ((newname = REQ_String(... */
1269
1270         } /* if (lock2) */
1271
1272         CurrentDir(olddir);
1273         UnLock(lock);
1274
1275     } /* if (lock) */
1276
1277 }
1278
1279 /*****************************************************************************************/
1280