workbench/libs/reqtools/filereqextra.c

   1 /*
   2     Copyright © 1995-2011, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: English
   7 */
   8
   9 /**************************************************************
  10 *                                                             *
  11 *      File/Font/Screenmode requester                         *
  12 *                                                             *
  13 *                                 (c) Nico François 1991-1994 *
  14 **************************************************************/
  15
  16 #include "filereq.h"
  17
  18 #define  D(x)
  19
  20 /****************************************************************************************/
  21
  22 extern struct LocaleBase *LocaleBase;
  23
  24 /****************************************************************************************/
  25
  26 static void REGARGS MarkHidden (GlobData *);
  27 static int REGARGS SkipEntry (GlobData *, struct ReqEntry *);
  28
  29 /****************************************************************************************/
  30
  31 /********************
  32 * Requester Display *
  33 ********************/
  34
  35 /****************************************************************************************/
  36
  37 void REGARGS AdjustScroller (GlobData *glob)
  38 {
  39     myGT_SetGadgetAttrs (glob->scrollergad, glob->reqwin, NULL, GTSC_Total, glob->buff->currentnum,
  40                                                                 GTSC_Top, glob->buff->gotopos,
  41                                                                 TAG_END);
  42 }
  43
  44 /****************************************************************************************/
  45
  46 void REGARGS ClearFilesRect (GlobData *glob)
  47 {
  48     SetAPen (glob->reqrp, glob->pens[BACKGROUNDPEN]);
  49     mySetWriteMask (glob->reqrp, glob->entrymask);
  50     RectFill (glob->reqrp, glob->boxleft, glob->boxtop - 1, glob->boxright,
  51                              glob->boxtop + glob->boxheight);
  52     mySetWriteMask (glob->reqrp, glob->rpmask);
  53 }
  54
  55 /****************************************************************************************/
  56
  57 void REGARGS ScrollerMoved (GlobData *glob, int code)
  58 {
  59     glob->buff->gotopos = code;
  60     if (!glob->buff->sorted)
  61     {
  62         glob->buff->pos = glob->buff->gotopos;
  63         UpdateDisplayList (glob);
  64         PrintFiles (glob);
  65         AdjustScroller (glob);
  66         glob->buff->sorted = TRUE;
  67     }
  68 }
  69
  70 /****************************************************************************************/
  71
  72 static void REGARGS MarkHidden (GlobData *glob)
  73 {
  74     struct ReqEntry     *entry;
  75     int                 skipflags;
  76
  77     if (glob->nodir) return;
  78
  79     for (entry = (struct ReqEntry *)glob->firstentry->re_Next;
  80          entry;
  81          entry = (struct ReqEntry *)entry->re_Next)
  82     {
  83         entry->re_Flags &= ~(ENTRYF_HIDDEN|ENTRYF_GHOSTED);
  84         if ((skipflags = SkipEntry (glob, entry))) entry->re_Flags |= skipflags;
  85     }
  86 }
  87
  88 /****************************************************************************************/
  89
  90 void REGARGS RethinkReqDisplay (GlobData *glob)
  91 {
  92     int num;
  93
  94     if (glob->nodir) return;
  95
  96     MarkHidden (glob);
  97     num = (glob->buff->currentnum = CountAllDeselect (glob, FALSE))
  98                                                                                                                                                             - glob->numentries;
  99     if (num < 0) glob->buff->gotopos = glob->buff->pos = 0;
 100     else if (glob->buff->pos > num) glob->buff->gotopos = glob->buff->pos = num;
 101
 102     AdjustScroller (glob);
 103     UpdateDisplayList (glob);
 104     PrintFiles (glob);
 105 }
 106
 107 /****************************************************************************************/
 108
 109 void REGARGS ClearDisplayList (GlobData *glob)
 110 {
 111     memset (glob->displaylist, 0, 50*4);
 112 }
 113
 114 /****************************************************************************************/
 115
 116 void REGARGS UpdateDisplayList (GlobData *glob)
 117 {
 118     struct ReqEntry     *entry;
 119     int                 i;
 120
 121     i = 0;
 122
 123     if (glob->buff->currentnum &&
 124         (entry = (struct ReqEntry *)glob->firstentry->re_Next))
 125     {
 126         while (i < glob->buff->pos)
 127         {
 128             if (!(entry->re_Flags & ENTRYF_HIDDEN))
 129             {
 130                 i++;
 131             }
 132
 133             entry = (struct ReqEntry *)entry->re_Next;
 134         }
 135
 136
 137         for (i = 0; entry && (i < glob->numentries);
 138              entry = (struct ReqEntry *)entry->re_Next)
 139         {
 140             if (!(entry->re_Flags & ENTRYF_HIDDEN))
 141             {
 142                 glob->displaylist[i++] = entry;
 143             }
 144         }
 145     }
 146
 147     while (i < glob->numentries)
 148     {
 149         glob->displaylist[i++] = NULL;
 150     }
 151 }
 152
 153 /****************************************************************************************/
 154
 155 static UWORD GhostPattern[] = { 0x4444, 0x1111 };
 156
 157 /****************************************************************************************/
 158
 159 /* Apply a ghosting pattern to a given rectangle in a rastport */
 160 static void REGARGS Ghost (struct RastPort *rp, UWORD pen, UWORD x, UWORD y, UWORD w, UWORD h)
 161 {
 162     SetAPen (rp, pen);
 163     SetBPen (rp, pen);
 164     SetDrMd (rp, JAM1);
 165     SetAfPt (rp, GhostPattern, 1);
 166     RectFill (rp, x, y, x + w - 1, y + h - 1);
 167     SetAfPt (rp, NULL, 0);
 168 }
 169
 170 /****************************************************************************************/
 171
 172 void REGARGS PrintEntry (GlobData *glob, int i)
 173 {
 174     struct TextExtent   extent;
 175     struct ReqEntry     *entry;
 176     struct RastPort     *reqrp = glob->reqrp;
 177     char                sizestr[16], tempstr[108], *volname = NULL, *str;
 178     int                 apen = 0, bpen = 0, top, len = 0, sizelen = 0, sizelenpix = 0, type, rectpen, left, entrytop;
 179     LONG                size;
 180
 181     mySetWriteMask (glob->reqrp, glob->entrymask);
 182     rectpen = BACKGROUNDPEN;
 183
 184     if ((entry = glob->displaylist[i]))
 185     {
 186         strcpy (tempstr, entry->re_Name);
 187         apen = TEXTPEN; bpen = BACKGROUNDPEN;
 188         sizestr[0] = 0;
 189         size = entry->re_Size;
 190         type = entry->re_Type;
 191         if (type == glob->directory_id)
 192         {
 193             strcpy (sizestr, GetStr (glob->catalog, MSG_DRAWER));
 194             apen = HIGHLIGHTTEXTPEN;
 195         }
 196         else if (type == FONT || (type == glob->file_id))
 197         {
 198 #ifdef __AROS__
 199             /* FIXME: AROS LocaleLibrary does not yet patch RawDoFmt. So "%lD" (uppercase D) does not work yet here!  */
 200             Dofmt (sizestr, " %ld", &size);
 201 #else
 202             Dofmt (sizestr, LocaleBase ? " %lD" : " %ld", &size);
 203 #endif
 204             if (type == FONT)
 205             {
 206                 StrCat (tempstr, sizestr);
 207                 sizestr[0] = 0;
 208             }
 209         }
 210         else if (type == ASSIGN)
 211         {
 212             strcpy (sizestr, GetStr (glob->catalog, MSG_ASSIGN));
 213             apen = HIGHLIGHTTEXTPEN;
 214         }
 215         else if (type == VOLUME)
 216         {
 217             if (size >= 0) Dofmt (sizestr, GetStr (glob->catalog, MSG_FULL), &size);
 218         }
 219
 220         if (type == VOLUME && entry->re_VolLen)
 221         {
 222              len = entry->re_VolLen;
 223              volname = entry->re_Name + len + 1;
 224         }
 225         else
 226             len = strlen (tempstr);
 227
 228         sizelen = strlen (sizestr);
 229         /* Cache the pixel size for each entry so
 230                 we only have to calculate this once. */
 231         if (entry->re_SizeLenPix)
 232             sizelenpix = entry->re_SizeLenPix;
 233         else
 234         {
 235             if (sizestr[0])
 236                 sizelenpix = StrWidth_noloc (&glob->itxt, sizestr);
 237             else
 238                 sizelenpix = 0;
 239
 240             if (sizelenpix < 256) entry->re_SizeLenPix = sizelenpix;
 241         }
 242
 243         if (entry->re_Flags & ENTRYF_SELECTED)
 244         {
 245             bpen = FILLPEN;
 246             if (type == glob->directory_id || type == ASSIGN)
 247             {
 248                 apen = BACKGROUNDPEN;
 249                 bpen = HIGHLIGHTTEXTPEN;
 250             }
 251             else /* VOLUME, FILE, FONT */
 252                 apen = FILLTEXTPEN;
 253
 254             rectpen = bpen;
 255         }
 256
 257     } /* if ((entry = glob->displaylist[i])) */
 258     else
 259     {
 260         if (glob->lastdisplaylistnum == -1) glob->lastdisplaylistnum = i;
 261     }
 262
 263     top = glob->boxtop + i * glob->entryheight;
 264     SetDrMd (glob->reqrp, JAM2);
 265     SetAPen (reqrp, glob->pens[rectpen]);
 266     entrytop = top;
 267     RectFill (reqrp, glob->boxleft, entrytop, glob->boxright, entrytop + glob->entryheight - 1);
 268
 269     if (entry)
 270     {
 271         SetAPen (reqrp, glob->pens[apen]);
 272         SetBPen (reqrp, glob->pens[bpen]);
 273         top += glob->fontbase + 1;
 274         str = tempstr;
 275         left = glob->boxleft + 2;
 276         Move (reqrp, left, top);
 277
 278         if (volname)
 279         {
 280             Text (reqrp, volname, strlen (volname));
 281             left += glob->maxvolwidth;
 282             Move (reqrp, left, top);
 283         }
 284
 285         /* Cache entry length, so we only need to calculate this once */
 286         if (!entry->re_EntryLen)
 287         {
 288              len = TextFit (reqrp, str, len, &extent, NULL, 1,
 289                                                      glob->boxright - left - sizelenpix - 5, glob->entryheight);
 290              entry->re_EntryLen = len;
 291         }
 292         else len = entry->re_EntryLen;
 293
 294         Text (reqrp, str, len);
 295
 296         if (sizelenpix)
 297         {
 298              Move (reqrp, glob->boxright - sizelenpix - 1, top);
 299              Text (reqrp, sizestr, sizelen);
 300         }
 301
 302         if (entry->re_Flags & ENTRYF_GHOSTED)
 303         {
 304             Ghost (reqrp, glob->pens[BACKGROUNDPEN],
 305                           glob->boxleft, entrytop,
 306                           glob->boxright - glob->boxleft + 1, glob->entryheight);
 307         }
 308
 309     } /* if (entry) */
 310
 311     mySetWriteMask (glob->reqrp, glob->rpmask);
 312 }
 313
 314 /****************************************************************************************/
 315
 316 void REGARGS PrintFiles (GlobData *glob)
 317 {
 318     int i;
 319
 320     glob->lastdisplaylistnum = -1;
 321     for (i = 0; i < glob->numentries; i++)
 322     {
 323         PrintEntry (glob, i);
 324     }
 325 }
 326
 327 /****************************************************************************************/
 328
 329 /********************
 330 * Requester entries *
 331 ********************/
 332
 333 /****************************************************************************************/
 334
 335 void REGARGS ClearAndInitReqBuffer (GlobData *glob)
 336 {
 337     glob->buff->gotopos = glob->buff->pos = glob->buff->currentnum = glob->buff->numfiles = 0;
 338     glob->firstentry = (struct ReqEntry *)AllocVecPooled(glob->buff->pool, sizeof (struct ReqEntry));
 339     glob->buff->firstname = glob->firstentry;
 340 }
 341
 342 /****************************************************************************************/
 343
 344 static UBYTE *REGARGS SkipDevName (UBYTE *entryname)
 345 {
 346     while (*entryname != ' ') entryname++;
 347     while (*entryname == ' ') entryname++;
 348
 349     return (entryname);
 350 }
 351
 352 /****************************************************************************************/
 353
 354 struct ReqEntry *REGARGS FindEntry (struct BufferData *buff, char *name, int size,
 355                                     int ctype, int *pos, ULONG flags)
 356 {
 357     struct ReqEntry     *curr, *lastname;
 358     int                 lastcmp, cmp, i = 0, cmptype;
 359     UBYTE               *entryname;
 360
 361     lastname = buff->firstname;
 362     curr = (struct ReqEntry *)lastname->re_Next;
 363     if ((ctype <= MAX_FILE_DIRECTORY) && buff->dirsmixed)
 364     {
 365         cmptype = 1;
 366     }
 367     else
 368     {
 369         while (curr && curr->re_Type < ctype)
 370         {
 371             lastname = curr;
 372             if (!(lastname->re_Flags & ENTRYF_HIDDEN)) i++;
 373             curr = (struct ReqEntry *)curr->re_Next;
 374         }
 375         cmptype = ctype;
 376     }
 377
 378     lastcmp = 1;
 379     while (curr)
 380     {
 381         if (ctype >= 0 && curr->re_Type > cmptype) break;
 382         entryname = curr->re_Name;
 383
 384         if (curr->re_Type == VOLUME && !(flags & FIND_VOLUMENAME))
 385         {
 386             cmp = Strnicmp (name, entryname, strlen(name));
 387         }
 388         else
 389         {
 390             if (curr->re_Type == VOLUME && (flags & FIND_VOLUMENAME))
 391                     entryname = SkipDevName (entryname);
 392             cmp = Stricmp (name, entryname);
 393         }
 394
 395         if ((cmp < 0) || (!cmp && (size < curr->re_Size))) break;
 396
 397         lastcmp = cmp;
 398         lastname = curr;
 399
 400         if (!(lastname->re_Flags & ENTRYF_HIDDEN)) i++;
 401
 402         curr = (struct ReqEntry *)curr->re_Next;
 403     }
 404
 405     if (pos)
 406     {
 407         if (lastname && (!(flags & FIND_EXACT) || !lastcmp))
 408         {
 409             *pos = i - 1;
 410             return (lastname);
 411         }
 412         else
 413         {
 414             *pos = 0;
 415             return (NULL);
 416         }
 417     }
 418
 419     return (lastname);
 420 }
 421
 422 /****************************************************************************************/
 423
 424 struct ReqEntry *REGARGS AddEntry (GlobData *glob, struct BufferData *buff,
 425                                 char *name, int size, int ctype)
 426 {
 427     struct ReqEntry     *lastname, *newentry;
 428     int                 pos, len = strlen( name ) + 1, currnum, skipflags;
 429     STRPTR              str, findname = name;
 430
 431     if( ctype == VOLUME )
 432     {
 433         findname = SkipDevName( findname );
 434     }
 435
 436     lastname = FindEntry( buff, findname, ( ( ctype == FONT ) ? size : MAXINT) ,
 437                           ctype, &pos, FIND_VOLUMENAME );
 438
 439     str = lastname->re_Name;
 440
 441     if( str && !Stricmp( name, str ) )
 442     {
 443         if( ctype <= MAX_FILE_DIRECTORY )
 444         {
 445             lastname->re_Size = size;
 446             return( lastname );
 447         }
 448
 449         len = 0;
 450     }
 451
 452     if( !( newentry = ( struct ReqEntry * ) AllocVecPooled(buff->pool, sizeof( struct ReqEntry ) + len ) ) )
 453     {
 454         return( NULL );
 455     }
 456
 457     if( len )
 458     {
 459         str = ( STRPTR ) newentry + sizeof( struct ReqEntry );
 460         strcpy( str, name );
 461     }
 462
 463     newentry->re_Name = str;
 464     newentry->re_Size = size;
 465     newentry->re_Type = ctype;
 466     newentry->re_Next = lastname->re_Next;
 467     lastname->re_Next = ( struct Node * ) newentry;
 468
 469     buff->numfiles++;
 470     buff->sorted = FALSE;
 471
 472     if( glob )
 473     {
 474         skipflags = SkipEntry( glob, newentry );
 475         newentry->re_Flags |= skipflags;
 476
 477         if( skipflags != ENTRYF_HIDDEN )
 478         {
 479             /* If file requester keep activated itempos up to date */
 480             if( ctype <= MAX_FILE_DIRECTORY )
 481             {
 482                 if( pos < glob->selectedpos )
 483                 {
 484                     glob->selectedpos++;
 485                 }
 486             }
 487
 488             currnum = buff->currentnum;
 489             buff->currentnum++;
 490
 491             if( ctype <= MAX_FILE_DIRECTORY )
 492             {   /* display now ? */
 493                 if (currnum < glob->numentries)
 494                 {
 495                     glob->displaylist[currnum] = newentry;
 496
 497                     if( !glob->quiet )
 498                     {
 499                         PrintEntry( glob, currnum );
 500                     }
 501                 }
 502                 else if( !glob->quiet )
 503                 {
 504                     AdjustScroller( glob );
 505                 }
 506             }
 507         }
 508     }
 509
 510     return( newentry );
 511 }
 512
 513 /****************************************************************************************/
 514
 515 int REGARGS EndsInDotInfo (char *str, int len)
 516 {
 517     if (len >= 5 && !Stricmp (&str[len-5], DOTINFOSTR)) return (TRUE);
 518     return (FALSE);
 519 }
 520
 521 /****************************************************************************************/
 522
 523 static int REGARGS SkipEntry (GlobData *glob, struct ReqEntry *entry)
 524 {
 525     char *str = entry->re_Name;
 526     int  len = strlen (str);
 527
 528     if (glob->reqtype == RT_FILEREQ)
 529     {
 530         if (entry->re_Type == glob->file_id)
 531         {
 532             if (!glob->wilddotinfo)
 533             {
 534                 if (EndsInDotInfo (str, len))
 535                 {
 536                     if (glob->freq->hideinfo) return (ENTRYF_HIDDEN);
 537
 538                     if (glob->matchpat[0])
 539                     {
 540                         int ret;
 541
 542                         str[len-5] = '\0';
 543                         ret = !MatchPatternNoCase (glob->matchpat, str);
 544                         str[len-5] = '.';
 545
 546                         return (ret ? ENTRYF_HIDDEN : 0);
 547                     }
 548                 }
 549             }
 550
 551             if (glob->flags & FREQF_NOFILES) return (ENTRYF_GHOSTED);
 552
 553             if (glob->matchpat[0])
 554                 if (!MatchPatternNoCase (glob->matchpat, str))
 555                     return (ENTRYF_HIDDEN);
 556         }
 557     }
 558     else if (glob->reqtype == RT_FONTREQ)
 559     {
 560             if (entry->re_Size < glob->minsize || entry->re_Size > glob->maxsize ||
 561                 ((glob->flags & FREQF_FIXEDWIDTH) && (entry->re_Flags & FPF_PROPORTIONAL)) ||
 562                 (!(glob->flags & FREQF_COLORFONTS) && (entry->re_Style & FSF_COLORFONT)))
 563                 return (ENTRYF_HIDDEN);
 564     }
 565     else
 566     {
 567         ;
 568     }
 569
 570     return (0);
 571 }
 572
 573 /****************************************************************************************/
 574
 575 int REGARGS CountAllDeselect (GlobData *glob, int dirsonly)
 576 {
 577     struct ReqEntry     *entry;
 578     int                 count = 0;
 579
 580     for (entry = (struct ReqEntry *)glob->firstentry->re_Next;
 581          entry;
 582          entry = (struct ReqEntry *)entry->re_Next)
 583     {
 584         if (!(entry->re_Flags & ENTRYF_HIDDEN)) count++;
 585         if (!dirsonly || entry->re_Type != glob->file_id)
 586         {
 587             if (entry->re_Flags & ENTRYF_SELECTED)
 588             {
 589                 glob->numselected--;
 590                 entry->re_Flags &= ~ENTRYF_SELECTED;
 591             }
 592         }
 593     }
 594
 595     glob->selectedpos = -1;
 596
 597     return (count);
 598 }
 599
 600 /****************************************************************************************/
 601
 602 void REGARGS SelectAll (GlobData *glob, char *pattern)
 603 {
 604     struct ReqEntry     *entry;
 605     char                *selpat;
 606     LONG                pattern_len;
 607
 608     pattern_len = strlen(pattern) * 2 + 2;
 609     selpat = AllocVec(pattern_len, MEMF_PUBLIC);
 610     if (selpat)
 611     {
 612         ParsePatternNoCase (pattern, selpat, pattern_len);
 613
 614         for (entry = (struct ReqEntry *)glob->firstentry->re_Next;
 615              entry;
 616              entry = (struct ReqEntry *)entry->re_Next)
 617         {
 618             if (!(entry->re_Flags & (ENTRYF_HIDDEN|ENTRYF_GHOSTED)))
 619             {
 620                 if ((entry->re_Type == glob->file_id) ||
 621                     (entry->re_Type == glob->directory_id && (glob->flags & FREQF_SELECTDIRS)))
 622                 {
 623                     if (MatchPatternNoCase (selpat, entry->re_Name))
 624                     {
 625                         if (!(entry->re_Flags & ENTRYF_SELECTED)) glob->numselected++;
 626                         entry->re_Flags |= ENTRYF_SELECTED;
 627                     }
 628                 }
 629             }
 630         }
 631         FreeVec(selpat);
 632     }
 633
 634     UpdateNumSelGad (glob);
 635     PrintFiles (glob);
 636     my_SetStringGadget (glob->reqwin, glob->filegad, NULL);
 637 }
 638
 639 /****************************************************************************************/
 640
 641 /*****************
 642 * File requester *
 643 *****************/
 644
 645 /****************************************************************************************/
 646
 647 void REGARGS UnLockReqLock (GlobData *glob)
 648 {
 649     glob->ledon = FALSE;
 650     RenderLED (glob);
 651     if (glob->lock) UnLock (glob->lock);
 652     glob->lock = BNULL;
 653 }
 654
 655 /****************************************************************************************/
 656
 657 BOOL REGARGS FindVolume (GlobData *glob, UBYTE *str, struct ReqEntry *curr)
 658 {
 659     struct ReqEntry     *entry;
 660     UBYTE               *s;
 661
 662     for (entry = (struct ReqEntry *)glob->firstentry->re_Next;
 663          entry;
 664          entry = (struct ReqEntry *)entry->re_Next)
 665     {
 666         if (entry != curr && entry->re_Type == VOLUME)
 667         {
 668             s = entry->re_Name;
 669             while (*s != ' ') s++;
 670             while (*s == ' ') s++;
 671             if (!Stricmp (s, str)) return (TRUE);
 672         }
 673     }
 674
 675     return (FALSE);
 676 }
 677
 678 /****************************************************************************************/
 679
 680 static BOOL
 681 IsDosVolume(struct DosList *dlist)
 682 {
 683     BOOL        isdev = FALSE;
 684     D_S( struct InfoData,id );
 685
 686     if( !dlist->dol_Task || DoPkt1( dlist->dol_Task, ACTION_DISK_INFO, (SIPTR)MKBADDR( id ) ) )
 687     {
 688         isdev = TRUE;
 689     }
 690
 691     return (isdev);
 692 }
 693
 694 /****************************************************************************************/
 695
 696 static BOOL
 697 IsDosDevice( struct DosList *dlist )
 698 {
 699     struct FileSysStartupMsg *fssm;
 700     struct DosEnvec *de;
 701     BOOL isdev = FALSE;
 702
 703     /* If it`s a device, do the hard check for a filesystem */
 704
 705     if (dlist->dol_Type == DLT_DEVICE)
 706     {
 707         fssm = ( struct FileSysStartupMsg * )BADDR( dlist->dol_misc.dol_handler.dol_Startup );
 708
 709         if( fssm )
 710         {
 711             if( TypeOfMem( fssm ) && TypeOfMem( BADDR( fssm->fssm_Device ) )
 712                     && TypeOfMem( BADDR( fssm->fssm_Environ ) ) )
 713             {
 714                 if( *( ( STRPTR ) BADDR( fssm->fssm_Device ) ) != 255 )
 715                 {
 716                     de = ( struct DosEnvec * ) BADDR( fssm->fssm_Environ );
 717
 718                     if( de && TypeOfMem( de ) )
 719                     {
 720                         if( de->de_Surfaces && de->de_BlocksPerTrack )
 721                         {
 722                             isdev = TRUE;
 723                         }
 724                     }
 725                 }
 726             }
 727         }
 728 #ifdef TASK_DEVICE
 729         else
 730         {
 731             isdev = ( dlist->dol_Task != NULL );
 732         }
 733 #endif
 734     }
 735
 736     return( isdev );
 737 }
 738
 739 /****************************************************************************************/
 740
 741 struct DeviceEntry
 742 {
 743     struct DeviceEntry  *next;
 744     struct MsgPort      *task;
 745     BOOL                resolved;
 746     UBYTE               name[ 42 ];
 747 };
 748
 749 /****************************************************************************************/
 750
 751 #define SIZE_NONE       ( ( ULONG ) -1 )
 752 #define SIZE_CALCULATE  ( ( ULONG ) -2 )
 753
 754 /****************************************************************************************/
 755
 756 static void
 757 AddDisk(
 758     GlobData *glob,
 759     struct DeviceEntry *deventry,
 760     UBYTE *devname,
 761     ULONG size,
 762     ULONG volreqflags )
 763 {
 764     struct rtVolumeEntry        volentry;
 765     struct ReqEntry             *entry;
 766     UBYTE                       buffer[80];
 767     int                         i, addentry;
 768
 769     D_S( struct InfoData, infodata );
 770
 771     addentry = TRUE;
 772
 773     if( volreqflags && glob->filterhook )
 774     {
 775         volentry.Type = DLT_DEVICE;
 776         volentry.Name = devname;
 777         addentry = CallHookPkt( glob->filterhook, glob->freq, &volentry );
 778     }
 779
 780     if( addentry )
 781     {
 782         if( size == SIZE_CALCULATE )
 783         {
 784             size = SIZE_NONE;
 785
 786             if( deventry->task &&
 787                     DoPkt1( deventry->task, ACTION_DISK_INFO, (SIPTR)MKBADDR( infodata ) ) )
 788             {
 789                 size = ( infodata->id_NumBlocksUsed * 100 +
 790                          infodata->id_NumBlocks / 2 ) /
 791                     infodata->id_NumBlocks;
 792             }
 793         }
 794
 795         i = StrWidth_noloc( &glob->itxt, deventry->name ) + StrWidth_noloc( &glob->itxt, "W" );
 796
 797         if( i > glob->maxvolwidth )
 798         {
 799             glob->maxvolwidth = i;
 800         }
 801
 802         DofmtArgs( buffer, "%s %s", devname, deventry->name );
 803
 804         if( ( entry = AddEntry( glob, glob->buff, buffer, size, VOLUME ) ) )
 805         {
 806             entry->re_VolLen = strlen( devname );
 807         }
 808     }
 809 }
 810
 811 /****************************************************************************************/
 812
 813 static struct DeviceEntry *
 814 AllocDevEntry( GlobData *glob, struct DosList *dlist, STRPTR name )
 815 {
 816     struct DeviceEntry  *deventry;
 817
 818     if( ( deventry = ( struct DeviceEntry * ) AllocVecPooled(
 819           glob->buff->pool, sizeof( struct DeviceEntry ) ) ) )
 820     {
 821         strcpy( deventry->name, name );
 822         deventry->task = dlist->dol_Task;
 823         deventry->resolved = FALSE;
 824     }
 825
 826     return( deventry );
 827 }
 828
 829 /****************************************************************************************/
 830
 831 static void
 832 GetVolName( BSTR bstr, STRPTR cstr )
 833 {
 834 #ifdef __AROS__
 835     /* In AROS, BPTR:s are handled differently on different systems
 836        (to be binary compatible on Amiga) */
 837
 838     if (bstr != BNULL)
 839     {
 840         LONG    length = AROS_BSTR_strlen(bstr);
 841         LONG    i;              /* Loop variable */
 842
 843         for (i = 0; i < length; i++)
 844         {
 845             cstr[i] = AROS_BSTR_getchar(bstr, i);
 846         }
 847
 848         cstr[i++] = ':';
 849         cstr[i] = 0;
 850
 851         D(bug("Found volume %s\n", cstr));
 852     }
 853 #else
 854     STRPTR str;
 855
 856     *cstr = 0;
 857
 858     if( ( str = BADDR( bstr ) ) )
 859     {
 860         LONG i;
 861
 862         for( i = *str++; i--; )
 863         {
 864             *cstr++ = *str++;
 865         }
 866
 867         *cstr++ = ':';
 868         *cstr = 0;
 869     }
 870 #endif
 871
 872 }
 873
 874 /****************************************************************************************/
 875
 876 void REGARGS
 877 AddDiskNames( GlobData *glob, ULONG volreqflags )
 878 {
 879     struct ReqEntry             *entry, *temp;
 880     struct DosList              *dlist;
 881     struct DeviceEntry          *deventry, *lastdeventry = NULL;
 882     struct rtVolumeEntry        volentry;
 883     UBYTE                       /* *bstr, *cstr, */ name[ 42 ], devname[ 36 ];
 884     /* WORD                     i; */
 885
 886     *glob->winaddr = ( APTR ) -1;
 887     glob->maxvolwidth = 0;
 888     dlist = LockDosList( LDF_VOLUMES | LDF_ASSIGNS | LDF_READ );
 889
 890     /* Add PROGDIR: assign is possible, just like reqtools_patch.lha
 891        from Aminet (by Mikolaj Calusinski) does. */
 892
 893     if (!(volreqflags & VREQF_NOASSIGNS))
 894     {
 895         if (((struct Process *)FindTask(NULL))->pr_HomeDir)
 896         {
 897             AddEntry(glob, glob->buff, "PROGDIR:", -1, ASSIGN);
 898         }
 899     }
 900
 901     while( ( dlist = NextDosEntry( dlist, LDF_VOLUMES | LDF_ASSIGNS | LDF_READ ) ) )
 902     {
 903         GetVolName(dlist->dol_Name, name);
 904         if (dlist->dol_Type == DLT_VOLUME)
 905         {
 906             if (IsDosVolume(dlist) && !(volreqflags & VREQF_NODISKS))
 907             {
 908                 if ((deventry = AllocDevEntry(glob, dlist, name)))
 909                 {
 910                     deventry->next = lastdeventry;
 911                     lastdeventry = deventry;
 912                 }
 913             }
 914         }
 915         else if (dlist->dol_Type == DLT_DIRECTORY ||
 916                  dlist->dol_Type == DLT_NONBINDING)
 917         {
 918             if (!(volreqflags & VREQF_NOASSIGNS))
 919             {
 920                 AddEntry(glob, glob->buff, name, -1, ASSIGN);
 921             }
 922         }
 923     }
 924
 925     /* Append device names to volumes */
 926     dlist = LockDosList( LDF_DEVICES | LDF_READ );
 927
 928     while( ( dlist = NextDosEntry( dlist, LDF_DEVICES | LDF_READ ) ) )
 929     {
 930         BOOL    devmatch;
 931
 932         deventry = lastdeventry;
 933         devmatch = FALSE;
 934
 935         while( deventry )
 936         {
 937             devmatch |= ( deventry->task == dlist->dol_Task );
 938             if( !deventry->resolved && deventry->task && ( deventry->task == dlist->dol_Task ) )
 939             {
 940                 GetVolName( dlist->dol_Name, devname );
 941                 AddDisk( glob, deventry, devname, SIZE_CALCULATE, volreqflags );
 942                 deventry->resolved = TRUE;
 943             }
 944
 945             deventry = deventry->next;
 946         }
 947
 948         if( !devmatch && ( volreqflags & VREQF_ALLDISKS ) &&
 949                 !( volreqflags & VREQF_NODISKS ) && IsDosDevice( dlist ) )
 950         {
 951             /* Device seems to be a DOS disk device, and it didn't belong
 952              * to a volume, and we should really show all devices in a
 953              * volume requester.
 954              */
 955             GetVolName( dlist->dol_Name, devname );
 956
 957             if( ( deventry = AllocDevEntry( glob, dlist, "-" ) ) )
 958             {
 959                 deventry->next = lastdeventry;
 960                 lastdeventry = deventry;
 961                 AddDisk( glob, deventry, devname, SIZE_NONE, volreqflags );
 962                 deventry->resolved = TRUE;
 963             }
 964         }
 965     }
 966
 967     UnLockDosList( LDF_DEVICES | LDF_READ );
 968     UnLockDosList( LDF_VOLUMES | LDF_ASSIGNS | LDF_READ );
 969
 970     /* Free temp volume list (and add remaining names if ALLDISKS is on) */
 971     while( ( deventry = lastdeventry ) )
 972     {
 973         if( !deventry->resolved /* && ( !volreqflags || ( volreqflags & VREQF_ALLDISKS ) ) */ )
 974         {
 975             AddDisk( glob, deventry, "-", SIZE_CALCULATE, volreqflags );
 976         }
 977
 978         lastdeventry = deventry->next;
 979         FreeVecPooled( glob->buff->pool, deventry );
 980     }
 981
 982     /* If volume requester filter assigns */
 983     if( volreqflags && glob->filterhook )
 984     {
 985         entry = glob->buff->firstname;
 986
 987         while( ( temp = entry ) )
 988         {
 989             entry = ( struct ReqEntry * ) entry->re_Next;
 990
 991             if( !entry )
 992             {
 993                 break;
 994             }
 995
 996             if( entry->re_Type == ASSIGN )
 997             {
 998                 volentry.Type = DLT_DIRECTORY;
 999                 volentry.Name = entry->re_Name;
1000
1001                 if( !CallHookPkt( glob->filterhook, glob->freq, &volentry ) )
1002                 {
1003                     temp->re_Next = entry->re_Next;
1004                     FreeVecPooled( glob->buff->pool, entry );
1005                     entry = temp;
1006                     glob->buff->currentnum--;
1007                 }
1008             }
1009         }
1010     }
1011
1012     *glob->winaddr = glob->reqwin;
1013 }
1014
1015 /****************************************************************************************/
1016
1017 BOOL REGARGS FindCurrentPos (GlobData *glob, char *name, int size, int ctype)
1018 {
1019     BOOL success;
1020
1021     MarkHidden (glob);
1022     success = FindEntry (glob->buff, name, size, ctype, ( int * ) &glob->buff->pos, FIND_EXACT) ? TRUE : FALSE;
1023     glob->buff->gotopos = glob->buff->pos;
1024
1025     return (success);
1026 }
1027
1028 /****************************************************************************************/
1029
1030 void REGARGS NewDir (GlobData *glob)
1031 {
1032     UnLockReqLock (glob);
1033     SetWindowTitles (glob->reqwin, glob->title, (char *)~0);
1034     FreeReqBuffer (glob->req);
1035     ClearDisplayList (glob);
1036     glob->newdir = TRUE;
1037     glob->clicked = ~0;
1038
1039     if (glob->freq)
1040     {
1041         SetFileDirMode (glob->buff, glob->flags);
1042         glob->file_id = glob->buff->file_id;
1043         glob->directory_id = glob->buff->directory_id;
1044     }
1045 }
1046
1047 /****************************************************************************************/
1048
1049 void REGARGS ShowDisks(GlobData *glob)
1050 {
1051
1052     if (!glob->disks)
1053     {
1054         UnLockReqLock (glob);
1055         FreeReqBuffer (glob->req);
1056         ClearAndInitReqBuffer (glob);
1057         glob->exnext = FALSE;
1058         glob->disks = TRUE;
1059         AddDiskNames (glob, glob->volumerequest);
1060         AdjustScroller (glob);
1061         UpdateDisplayList (glob);
1062         PrintFiles (glob);
1063         glob->buff->sorted = TRUE;
1064         glob->selectedpos = -1;
1065     }
1066 }
1067
1068 /****************************************************************************************/
1069
1070 void REGARGS UpdateNumSelGad (GlobData *glob)
1071 {
1072     int  top;
1073     char str[6];
1074
1075     if (glob->numselectedgad)
1076     {
1077         Dofmt (str, "%4ld", &glob->numselected);
1078
1079         SetAPen (glob->reqrp, glob->pens[TEXTPEN]);
1080         SetBPen (glob->reqrp, glob->pens[BACKGROUNDPEN]);
1081         SetDrMd (glob->reqrp, JAM2);
1082
1083         top = glob->numselectedgad->TopEdge + 3;
1084
1085         Move (glob->reqrp, glob->numselectedgad->LeftEdge + glob->numselectedoff + 8,
1086                         top + glob->reqfont->tf_Baseline);
1087         Text (glob->reqrp, str, 4);
1088
1089         SetDrMd (glob->reqrp, JAM2);
1090         SetAPen (glob->reqrp, glob->pens[BACKGROUNDPEN]);
1091
1092         RectFill (glob->reqrp, glob->reqrp->cp_x,
1093                                top,
1094                                glob->numselectedgad->LeftEdge + glob->numselectedgad->Width - 3,
1095                                top + glob->fontheight - 1);
1096     }
1097 }
1098
1099 /****************************************************************************************/
1100
1101 /*****************
1102 * Font requester *
1103 *****************/
1104
1105 /****************************************************************************************/
1106
1107 static struct Region *MyInstallRegion (struct Window *win, struct Region *reg, int refresh)
1108 {
1109     struct Region *oldregion;
1110
1111     LockLayerInfo(&win->WScreen->LayerInfo);
1112
1113     if (refresh) GT_EndRefresh (win, FALSE);
1114
1115     oldregion = InstallClipRegion (win->WLayer, reg);
1116     if (refresh) GT_BeginRefresh (win);
1117
1118     UnlockLayerInfo(&win->WScreen->LayerInfo);
1119
1120     return (oldregion);
1121 }
1122
1123 /****************************************************************************************/
1124
1125 void REGARGS ShowFontSample (GlobData *glob, int refresh, int dowait)
1126 {
1127     struct DiskfontBase *DiskfontBase = glob->diskfontbase;
1128     struct TextFont     *font;
1129     struct Rectangle    rect;
1130     struct Region       *oldregion, *region;
1131     char                *message = "0123 aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ";
1132     UWORD               *cmap = NULL;
1133     ULONG               style = glob->fontstyle, count = glob->colcount;
1134     APTR                winlock = NULL;
1135
1136     if (dowait) winlock = rtLockWindow (glob->reqwin);
1137
1138     if (glob->flags & FREQF_SCALE)
1139         glob->fontreq->Attr.ta_Flags &= ~FPF_DESIGNED;
1140
1141     if (!(font = OpenDiskFont (&glob->fontreq->Attr)))
1142     {
1143         font = glob->reqfont;
1144         message = GetStr (glob->catalog, MSG_COULDNT_OPEN_FONT);
1145         style = 0;
1146     }
1147
1148     rect.MinX = glob->fontdisplayleft;
1149     rect.MaxX = glob->fontdisplayright;
1150     rect.MinY = glob->fontdisplaytop;
1151     rect.MaxY = glob->fontdisplaytop + glob->sampleheight - 1;
1152
1153     if ( ( region = NewRegion() ) )
1154     {
1155         OrRectRegion (region, &rect);
1156
1157         oldregion = MyInstallRegion (glob->reqwin, region, refresh);
1158
1159         SetFont (glob->reqrp, font);
1160         SetSoftStyle (glob->reqrp, style, ~0);
1161         SetAPen (glob->reqrp, glob->pens[TEXTPEN]);
1162         SetBPen (glob->reqrp, glob->pens[BACKGROUNDPEN]);
1163
1164         if (font->tf_Style & FSF_COLORFONT)
1165         {
1166             struct ColorFontColors *cfc;
1167
1168             cfc = ((struct ColorTextFont *)font)->ctf_ColorFontColors;
1169             if (cfc)
1170             {
1171                 count = cfc->cfc_Count;
1172                 cmap = cfc->cfc_ColorTable;
1173             }
1174         }
1175
1176         if (glob->flags & FREQF_CHANGEPALETTE)
1177         {
1178             if (cmap) LoadRGB4 (glob->vp, cmap, count);
1179             else LoadCMap (glob->vp, glob->colormap);
1180         }
1181
1182         if (!refresh) SetRast (glob->reqrp, glob->pens[BACKGROUNDPEN]);
1183
1184         Move (glob->reqrp, glob->fontdisplayleft,
1185                            glob->fontdisplaytop + (glob->sampleheight - font->tf_YSize) / 2
1186                                                 + font->tf_Baseline);
1187         Text (glob->reqrp, message, strlen(message));
1188
1189         MyInstallRegion (glob->reqwin, oldregion, refresh);
1190         DisposeRegion (region);
1191
1192         SetFont (glob->reqrp, glob->reqfont);
1193         SetSoftStyle (glob->reqrp, 0, ~0);
1194     }
1195
1196 /*endshowsample:*/
1197     CloseFont (font);
1198     if (dowait) rtUnlockWindow (glob->reqwin, winlock);
1199 }
1200
1201 /****************************************************************************************/
1202
1203 /***********************
1204 * ScreenMode requester *
1205 ***********************/
1206
1207 /****************************************************************************************/
1208
1209 ULONG ASM myGetDisplayInfoData (
1210     OPT_REGPARAM(a1, UBYTE *, buf),
1211     OPT_REGPARAM(d0, unsigned long, size),
1212     OPT_REGPARAM(d1, unsigned long, tagID),
1213     OPT_REGPARAM(d2, unsigned long, displayID))
1214 {
1215     return (GetDisplayInfoData (FindDisplayInfo (displayID),
1216                                 buf, size, tagID, displayID));
1217 }
1218
1219 /****************************************************************************************/
1220
1221 int REGARGS GetModeData (GlobData *glob, ULONG id, int *mon)
1222 {
1223     struct MonitorInfo  monitorinfo;
1224     ULONG               propflags;
1225     int                 modewidth, stdmode = TRUE;
1226     char                *str, *monstr;
1227
1228     if ((myGetDisplayInfoData ((UBYTE *)&glob->diminfo,
1229                                 sizeof (struct DimensionInfo), DTAG_DIMS, id) <= 0) ||
1230         (myGetDisplayInfoData ((UBYTE *)&glob->dispinfo,
1231                                 sizeof (struct DisplayInfo), DTAG_DISP, id) <= 0))
1232     {
1233         return (FALSE);
1234     }
1235
1236     modewidth = glob->diminfo.Nominal.MaxX - glob->diminfo.Nominal.MinX + 1;
1237     propflags = glob->dispinfo.PropertyFlags;
1238
1239     if ((glob->flags & SCREQF_GUIMODES) && !(propflags & DIPF_IS_WB))
1240         return (FALSE);
1241
1242     *mon = ((id & MONITOR_ID_MASK) >> 16) - 1;
1243
1244     if (myGetDisplayInfoData ((UBYTE *)&glob->nameinfo,
1245                               sizeof (struct NameInfo), DTAG_NAME, id) <= 0)
1246     {
1247         str = glob->nameinfo.Name;
1248         if ((myGetDisplayInfoData ((UBYTE *)&monitorinfo, sizeof (struct MonitorInfo), DTAG_MNTR, id) > 0)
1249             && monitorinfo.Mspc)
1250         {
1251             monstr = monitorinfo.Mspc->ms_Node.xln_Name;
1252             while (*monstr > '.') *str++ = ToUpper (*monstr++);
1253             *str++ = ':';
1254         }
1255
1256         DofmtArgs (str, "%ld x %ld", modewidth,
1257                                      glob->diminfo.Nominal.MaxY - glob->diminfo.Nominal.MinY + 1);
1258
1259         if (propflags & DIPF_IS_HAM)
1260         {
1261             StrCat (str, GetStr (glob->catalog, MSG_DASH_HAM));
1262             stdmode = FALSE;
1263         }
1264
1265         if (propflags & DIPF_IS_EXTRAHALFBRITE)
1266         {
1267             StrCat (str, GetStr (glob->catalog, MSG_DASH_EHB));
1268             stdmode = FALSE;
1269         }
1270
1271         if (propflags & DIPF_IS_LACE)
1272             StrCat (str, GetStr (glob->catalog, MSG_DASH_INTERLACED));
1273
1274     }
1275
1276     /* check property flags using mask */
1277     if ((propflags & glob->propertymask) != (glob->propertyflags & glob->propertymask))
1278         return (FALSE);
1279
1280     /* check if depth larger than minimum depth */
1281     if (glob->diminfo.MaxDepth < glob->mindepth) return (FALSE);
1282
1283     /* GUI modes ? */
1284     if (glob->flags & SCREQF_GUIMODES)
1285     {
1286         return (stdmode && (modewidth >= 640));
1287     }
1288
1289     /* include non-standard modes ? */
1290     if (!(glob->flags & SCREQF_NONSTDMODES)) return (stdmode);
1291
1292     return (TRUE);
1293 }
1294
1295 /****************************************************************************************/
1296
1297 void REGARGS SetTextGad (GlobData *glob, struct Gadget *gad, char *text)
1298 {
1299     if (!gad) return;
1300
1301     myGT_SetGadgetAttrs (gad, glob->reqwin, NULL, GTTX_Text, (IPTR) text,
1302                                                   TAG_END);
1303 }
1304
1305 /****************************************************************************************/
1306
1307 void REGARGS SetSizeGads (GlobData *glob)
1308 {
1309     if (glob->usedefwidth) glob->width = glob->defwidth;
1310     if (glob->usedefheight) glob->height = glob->defheight;
1311     if (glob->width > glob->maxwidth) glob->width = glob->maxwidth;
1312     if (glob->width < glob->minwidth) glob->width = glob->minwidth;
1313
1314     my_SetIntegerGadget (glob->reqwin, glob->widthgad, glob->width);
1315
1316     if (glob->height > glob->maxheight) glob->height = glob->maxheight;
1317     if (glob->height < glob->minheight) glob->height = glob->minheight;
1318
1319     my_SetIntegerGadget (glob->reqwin, glob->heightgad, glob->height);
1320 }
1321
1322 /****************************************************************************************/
1323
1324 LONG REGARGS IntGadgetBounds (GlobData *glob, struct Gadget *gad,
1325                                                   LONG min, LONG max)
1326 {
1327     LONG val;
1328
1329     val = ((struct StringInfo *)gad->SpecialInfo)->LongInt;
1330
1331     if (val > max)
1332     {
1333         val = max;
1334         my_SetIntegerGadget (glob->reqwin, gad, val);
1335     }
1336
1337     if (val < min)
1338     {
1339         val = min;
1340         my_SetIntegerGadget (glob->reqwin, gad, val);
1341     }
1342
1343     return (val);
1344 }
1345
1346 /****************************************************************************************/
1347
1348 int overscantrans[] = { 0, 3, 4, 1 };
1349
1350 /****************************************************************************************/
1351
1352 void REGARGS GetModeDimensions (GlobData *glob)
1353 {
1354     struct Rectangle *rect;
1355
1356     if (glob->modeid != INVALID_ID)
1357     {
1358         rect = &(&glob->diminfo.Nominal)[overscantrans[glob->overscantype]];
1359         glob->defwidth = rect->MaxX - rect->MinX + 1;
1360         glob->defheight = rect->MaxY - rect->MinY + 1;
1361     }
1362     else glob->defwidth = glob->defheight = 0;
1363 }
1364
1365 /****************************************************************************************/
1366
1367 void BuildColStr (char *colstr, LONG colors, ULONG id)
1368 {
1369     colors = 1 << colors;
1370
1371     if (id & HAM)
1372         colors = (colors == 128 ? 4096 : 16777216L);
1373
1374     if (id & EXTRA_HALFBRITE )
1375         colors = 64;
1376
1377     if (colors <= 9999)
1378     {
1379         DofmtArgs (colstr, "%ld", colors);
1380         return;
1381     }
1382
1383     colors /= 1024;
1384     if (colors <= 999)
1385     {
1386         DofmtArgs (colstr, "%ldK", colors);
1387         return;
1388     }
1389
1390     colors /= 1024;
1391
1392     DofmtArgs (colstr, "%ldM", colors);
1393 }
1394
1395 /****************************************************************************************/
1396
1397 void REGARGS UpdateDepthDisplay (GlobData *glob, int depth, ULONG id)
1398 {
1399     BuildColStr (glob->currcolstr, depth, id);
1400
1401     myGT_SetGadgetAttrs (glob->currcolgad, glob->reqwin, NULL, GTTX_Text, (IPTR) glob->currcolstr,
1402                                                                TAG_END);
1403 }
1404
1405 /****************************************************************************************/
1406
1407 void REGARGS UpdateDepthGad (GlobData *glob)
1408 {
1409     UpdateDepthDisplay (glob, glob->depth, glob->modeid);
1410
1411     myGT_SetGadgetAttrs (glob->depthgad, glob->reqwin, NULL, GTSL_Min, glob->currmindepth,
1412                                                              GTSL_Max, glob->currmaxdepth,
1413                                                              GTSL_Level, glob->depth,
1414                                                              GA_Disabled, (glob->currmindepth == glob->currmaxdepth),
1415                                                              TAG_END);
1416 }
1417
1418 /****************************************************************************************/
1419
1420 void REGARGS DisplayModeAttrs (GlobData *glob)
1421 {
1422     if (glob->modeid != INVALID_ID)
1423     {
1424         int maxdepth = glob->diminfo.MaxDepth, mindepth = 1;
1425
1426         if( maxdepth < 0 || maxdepth > 24 )
1427         {
1428             maxdepth = 24;
1429         }
1430
1431         if (glob->depth > maxdepth || !(glob->flags & SCREQF_DEPTHGAD))
1432             glob->depth = maxdepth;
1433
1434         /* if (glob->modeid & HAM) mindepth = maxdepth = glob->depth = 12; */
1435         /* if (glob->modeid & EXTRA_HALFBRITE) mindepth = maxdepth = glob->depth = 6; */
1436
1437         if (glob->depthgad)
1438         {
1439             if (glob->modeid & EXTRA_HALFBRITE)
1440             {
1441                 mindepth = maxdepth;
1442             }
1443
1444             if (glob->modeid & HAM)
1445             {
1446                 mindepth = 7;
1447
1448                 if (maxdepth == 6)
1449                     ++maxdepth;
1450             }
1451
1452             glob->currmaxdepth = maxdepth; glob->currmindepth = mindepth;
1453
1454             if (glob->currmaxdepth > glob->maxdepth) glob->currmaxdepth = glob->maxdepth;
1455             if (glob->currmindepth < glob->mindepth) glob->currmindepth = glob->mindepth;
1456             if (glob->depth > glob->currmaxdepth) glob->depth = glob->currmaxdepth;
1457             if (glob->depth < glob->currmindepth) glob->depth = glob->currmindepth;
1458
1459             UpdateDepthGad (glob);
1460             BuildColStr (glob->maxcolstr, glob->currmaxdepth, glob->modeid);
1461             myGT_SetGadgetAttrs (glob->maxcolgad, glob->reqwin, NULL,
1462                             GTTX_Text, (IPTR) glob->maxcolstr, TAG_END);
1463         }
1464         SetSizeGads (glob);
1465
1466     } /* if (glob->modeid != INVALID_ID) */
1467 }
1468
1469 /****************************************************************************************/