workbench/libs/reqtools/general.c

   1
   2 /* INCLUDES */
   3
   4 #include <exec/types.h>
   5 #include <exec/memory.h>
   6 #include <exec/execbase.h>
   7 #include <libraries/dos.h>
   8 #include <libraries/dosextens.h>
   9 #include <graphics/gfxmacros.h>
  10 #include <graphics/videocontrol.h>
  11 #include <graphics/view.h>
  12 #include <graphics/gfxbase.h>
  13 #include <libraries/gadtools.h>
  14 #include <intuition/intuition.h>
  15 #include <intuition/intuitionbase.h>
  16 #include <intuition/imageclass.h>
  17 #include <proto/graphics.h>
  18 #include <proto/exec.h>
  19 #include <proto/intuition.h>
  20 #include <proto/dos.h>
  21 #include <proto/gadtools.h>
  22 #include <proto/utility.h>
  23 #include <clib/macros.h>
  24 #include <string.h>
  25
  26 #include <libraries/reqtools.h>
  27 #include <proto/reqtools.h>
  28
  29 #ifdef __AROS__
  30 #include <aros/asmcall.h>
  31 #endif
  32
  33 #include "filereq.h"
  34
  35 /****************************************************************************************/
  36
  37 /* Use ColorMap.Count to find out number of palette entried on screen */
  38 //#define DO_CM_DEPTH
  39
  40 /****************************************************************************************/
  41
  42 UWORD CHIP waitpointer[] =
  43 {
  44     0x0000,0x0000,
  45     0x0400,0x07C0,0x0000,0x07C0,0x0100,0x0380,0x0000,0x07E0,
  46     0x07C0,0x1FF8,0x1FF0,0x3FEC,0x3FF8,0x7FDE,0x3FF8,0x7FBE,
  47     0x7FFC,0xFF7F,0x7EFC,0xFFFF,0x7FFC,0xFFFF,0x3FF8,0x7FFE,
  48     0x3FF8,0x7FFE,0x1FF0,0x3FFC,0x07C0,0x1FF8,0x0000,0x07E0,
  49     0x0000,0x0000,
  50 };
  51
  52 /****************************************************************************************/
  53
  54 extern struct Library           *GadToolsBase;
  55 extern struct DosLibrary        *DOSBase;
  56 extern struct IntuitionBase     *IntuitionBase;
  57 extern struct GfxBase           *GfxBase;
  58 extern struct ReqToolsBase      *ReqToolsBase;
  59 #if defined(__AROS__) || defined(__GNUC__)
  60 extern struct UtilityBase       *UtilityBase;
  61 #else
  62 extern struct Library           *UtilityBase;
  63 #endif
  64
  65 /****************************************************************************************/
  66
  67 int ASM SAVEDS GetVScreenSize (
  68         REGPARAM(a0, struct Screen *, scr),
  69         REGPARAM(a1, int *, width),
  70         REGPARAM(a2, int *, height))
  71 {
  72     struct ViewPortExtra        *vpe;
  73     struct Rectangle            dispclip, *clip;
  74     ULONG                       getvpetags[3];
  75     int                         ht;
  76 #ifndef USE_FORBID
  77     struct Screen               *pubscr;
  78     ULONG                       ilock = 0L;
  79     BOOL                        isfirst;
  80 #endif
  81
  82
  83     getvpetags[0] = VTAG_VIEWPORTEXTRA_GET;
  84     getvpetags[1] = (ULONG)&vpe;
  85     getvpetags[2] = TAG_END;
  86
  87 #ifdef USE_FORBID
  88
  89     Forbid();
  90
  91 #ifdef __AROS__
  92 #warning No VideoControl in AROS, yet
  93 #else
  94     if (IntuitionBase->FirstScreen == scr &&
  95         VideoControl (scr->ViewPort.ColorMap, (struct TagItem *)getvpetags) == 0)
  96     {
  97         clip = &((struct ViewPortExtra *)getvpetags[1])->DisplayClip;
  98     }
  99     else
 100     {
 101 #endif
 102         QueryOverscan (GetVPModeID (&scr->ViewPort), &dispclip, OSCAN_TEXT);
 103         clip = &dispclip;
 104 #ifndef __AROS__
 105     }
 106 #endif
 107
 108     Permit();
 109
 110 #else
 111
 112     if ((pubscr = LockPubScreenByAddr(scr)))
 113     {
 114         /* Cool, we got a lock on the screen, we don't need to Forbid() */
 115         ilock = LockIBase(0);
 116     }
 117     else
 118     {
 119         /* damn it, not a pubscreen, Forbid() as a last resort */
 120         Forbid();
 121     }
 122
 123     isfirst = (IntuitionBase->FirstScreen == scr);
 124
 125     if (pubscr)
 126     {
 127         UnlockIBase(ilock);
 128     }
 129
 130 #ifdef __AROS__
 131 #warning No VideoControl in AROS, yet
 132 #else
 133     if (isfirst &&
 134         VideoControl (scr->ViewPort.ColorMap, (struct TagItem *)getvpetags) == 0)
 135     {
 136         clip = &((struct ViewPortExtra *)getvpetags[1])->DisplayClip;
 137     }
 138     else
 139     {
 140 #endif
 141         QueryOverscan (GetVPModeID (&scr->ViewPort), &dispclip, OSCAN_TEXT);
 142         clip = &dispclip;
 143 #ifndef __AROS__
 144     }
 145 #endif
 146     if (pubscr)
 147     {
 148         UnlockPubScreen(NULL, pubscr);
 149     }
 150     else
 151     {
 152         Permit();
 153     }
 154
 155 #endif
 156
 157     *width = clip->MaxX - clip->MinX + 1;
 158     *height = ht = clip->MaxY - clip->MinY + 1;
 159
 160     if (scr->Width < *width) *width = scr->Width;
 161     if (scr->Height < *height) *height = scr->Height;
 162
 163     return ((ht >= 400) ? 4 : 2);
 164 }
 165
 166 /****************************************************************************************/
 167
 168 struct Screen *REGARGS LockPubScreenByAddr (struct Screen *scr)
 169 {
 170     struct List *pubscreenlist;
 171     struct PubScreenNode *pubscreennode;
 172     UBYTE pubscreenname[MAXPUBSCREENNAME + 1];
 173
 174     pubscreenname[0] = '\0';
 175
 176     pubscreenlist = LockPubScreenList();
 177     pubscreennode = (struct PubScreenNode *) pubscreenlist->lh_Head;
 178     while (pubscreennode->psn_Node.ln_Succ)
 179     {
 180         if (pubscreennode->psn_Screen == scr)
 181         {
 182             strcpy(pubscreenname, pubscreennode->psn_Node.ln_Name);
 183             break;
 184         }
 185         pubscreennode = (struct PubScreenNode *) pubscreennode->psn_Node.ln_Succ;
 186     }
 187     UnlockPubScreenList();
 188
 189     /* If we found a matching pubscreen try to lock it (note: can fail) */
 190     if (pubscreenname[0])
 191     {
 192         scr = LockPubScreen(pubscreenname);
 193     }
 194     else
 195     {
 196         scr = NULL;
 197     }
 198
 199     return scr;
 200 }
 201
 202 /****************************************************************************************/
 203
 204
 205 #undef ThisProcess
 206 #define ThisProcess()           ( ( APTR ) FindTask( NULL ) )
 207
 208 /****************************************************************************************/
 209
 210 struct Screen *REGARGS GetReqScreen (
 211         struct NewWindow *nw, struct Window **prwin, struct Screen *scr, char *pubname)
 212 {
 213     struct Window  *win = *prwin;
 214     struct Process *proc;
 215
 216     if (!pubname && !scr && !win)
 217     {
 218         proc = ThisProcess();
 219         if (proc->pr_Task.tc_Node.ln_Type == NT_PROCESS) win = proc->pr_WindowPtr;
 220     }
 221
 222     nw->Type = CUSTOMSCREEN;
 223     if (scr && !win)
 224     {
 225         struct Screen *pubscr;
 226
 227         /* Try to lock the screen as a public screen */
 228         if ((pubscr = LockPubScreenByAddr(scr)))
 229         {
 230             scr = pubscr;
 231             nw->Type = PUBLICSCREEN;
 232         }
 233         /* FIXME: probably should do something smart if the locking fail.
 234            RT_Screen is more than dangerous if you ask me... - Piru */
 235     }
 236     else
 237     {
 238         if (win && (ULONG)win != ~0) scr = win->WScreen;
 239         else
 240         {
 241             if (!(scr = LockPubScreen (pubname)))
 242                 if (!(scr = LockPubScreen (NULL))) return (NULL);
 243
 244             nw->Type = PUBLICSCREEN;
 245             win = NULL;
 246         }
 247     }
 248     *prwin = win;
 249     return (nw->Screen = scr);
 250 }
 251
 252 /****************************************************************************************/
 253
 254 #ifndef DO_CM_DEPTH
 255 static int VpDepth (struct ViewPort *vp)
 256 {
 257     ULONG       modeid = GetVPModeID (vp);
 258     int         depth;
 259
 260     depth = vp->RasInfo->BitMap->Depth;
 261
 262     if (modeid & HAM_KEY) depth -= 2;
 263     if (modeid & EXTRAHALFBRITE_KEY) depth = 5;
 264
 265     if( depth > 8 )
 266     {
 267         depth = 8;
 268     }
 269
 270     return (depth);
 271 }
 272 #endif
 273
 274 /****************************************************************************************/
 275
 276 int REGARGS
 277 GetVpCM( struct ViewPort *vp, APTR *cmap)
 278 {
 279
 280 #ifdef DO_CM_DEPTH
 281     int numcols;
 282
 283     if( !vp->ColorMap )
 284     {
 285             return( 0 );
 286     }
 287
 288     numcols = vp->ColorMap->Count;
 289 #else
 290     int depth, numcols;
 291
 292     if( !vp->ColorMap )
 293     {
 294         return( 0 );
 295     }
 296
 297     depth = VpDepth (vp);
 298     numcols = (1 << depth);
 299 #endif
 300     if( GfxBase->LibNode.lib_Version >= 39 )
 301     {
 302         if( ( *cmap = AllocVec( ( numcols * 3 + 2 ) * 4, MEMF_PUBLIC | MEMF_CLEAR ) ) )
 303         {
 304             ( ( UWORD * ) ( *cmap ) )[ 0 ] = numcols;
 305         }
 306     }
 307     else
 308     {
 309         *cmap = AllocVec( numcols * 2, MEMF_PUBLIC | MEMF_CLEAR );
 310     }
 311
 312     if( *cmap )
 313     {
 314         RefreshVpCM( vp, *cmap );
 315         return( depth );
 316     }
 317     else
 318     {
 319         return( 0 );
 320     }
 321 }
 322
 323 /****************************************************************************************/
 324
 325 void REGARGS
 326 RefreshVpCM( struct ViewPort *vp, APTR cmap )
 327 {
 328 #ifdef DO_CM_DEPTH
 329     int numcols, i;
 330
 331     numcols = vp->ColorMap->Count;
 332 #else
 333     int i, depth, numcols;
 334
 335     depth = VpDepth( vp );
 336     numcols = ( 1 << depth );
 337 #endif
 338     if( GfxBase->LibNode.lib_Version >= 39 )
 339     {
 340         GetRGB32( vp->ColorMap, 0, numcols, ( ( ULONG * ) cmap ) + 1 );
 341     }
 342     else
 343     {
 344         for( i = 0; i < numcols; i++ )
 345         {
 346             ( ( UWORD * ) cmap )[ i ] = GetRGB4( vp->ColorMap, i );
 347         }
 348     }
 349 }
 350
 351 /****************************************************************************************/
 352
 353 void REGARGS LoadCMap (struct ViewPort *vp, APTR cmap)
 354 {
 355     if (GfxBase->LibNode.lib_Version >= 39) LoadRGB32 (vp, cmap);
 356 #ifdef DO_CM_DEPTH
 357     else LoadRGB4 (vp, cmap, vp->ColorMap->Count);
 358 #else
 359     else LoadRGB4 (vp, cmap, (1 << VpDepth (vp)));
 360 #endif
 361 }
 362
 363 /****************************************************************************************/
 364
 365 void REGARGS FreeVpCM (struct ViewPort *vp, APTR cmap, BOOL restore)
 366 {
 367     if (restore && cmap) LoadCMap (vp, cmap);
 368     FreeVec (cmap);
 369 }
 370
 371 /****************************************************************************************/
 372
 373 void REGARGS InitNewGadget (struct NewGadget *ng,
 374                 int x, int y, int w, int h, char *s, UWORD id)
 375 {
 376     ng->ng_LeftEdge = x; ng->ng_TopEdge = y; ng->ng_Width = w; ng->ng_Height = h;
 377     ng->ng_GadgetText = s; ng->ng_GadgetID = id;
 378 }
 379
 380 /****************************************************************************************/
 381
 382 struct TextFont * REGARGS GetReqFont (struct TextAttr *attr,
 383                 struct TextFont *deffont, int *fontheight, int *fontwidth, int allowprop)
 384 {
 385     struct TextFont     *ft;
 386     int                 forcedef;
 387
 388     forcedef = (rtLockPrefs()->Flags & RTPRF_DEFAULTFONT);
 389     rtUnlockPrefs();
 390
 391     ft = OpenFont (attr);
 392     if (!ft || forcedef || (!allowprop && (ft->tf_Flags & FPF_PROPORTIONAL)))
 393     {
 394         if (ft) CloseFont (ft);
 395         if (deffont) ft = deffont;
 396         else ft = GfxBase->DefaultFont;
 397
 398         attr->ta_Name = ft->tf_Message.mn_Node.ln_Name;
 399         attr->ta_YSize = ft->tf_YSize;
 400         attr->ta_Style = ft->tf_Style;
 401         attr->ta_Flags = ft->tf_Flags;
 402         ft = OpenFont (attr);
 403     }
 404
 405     if (ft)
 406     {
 407         *fontheight = ft->tf_YSize;
 408         *fontwidth = ft->tf_XSize;
 409     }
 410
 411     return (ft);
 412 }
 413
 414 /****************************************************************************************/
 415
 416 struct IntuiMessage *REGARGS GetWin_GT_Msg (struct Window *win,
 417                                             struct Hook *hook, APTR req)
 418 {
 419     struct IntuiMessage *imsg, *reqmsg;
 420
 421     while ((imsg = (struct IntuiMessage *)GetMsg (win->UserPort)))
 422         if ((reqmsg = ProcessWin_Msg (win, imsg, hook, req))) return (reqmsg);
 423
 424     return (NULL);
 425 }
 426
 427 /****************************************************************************************/
 428
 429 struct IntuiMessage *REGARGS ProcessWin_Msg (struct Window *win,
 430                                             struct IntuiMessage *imsg, struct Hook *hook, APTR req)
 431 {
 432     struct IntuiMessage *reqmsg;
 433
 434     if (imsg->IDCMPWindow == win)
 435     {
 436         reqmsg = GT_FilterIMsg (imsg);
 437         if (reqmsg) return (reqmsg);
 438         ReplyMsg ((struct Message *)imsg);
 439     }
 440     else
 441     {
 442         if (hook) CallHookPkt (hook, req, imsg);
 443         ReplyMsg ((struct Message *)imsg);
 444     }
 445
 446     return (NULL);
 447 }
 448
 449 /****************************************************************************************/
 450
 451 void REGARGS Reply_GT_Msg (struct IntuiMessage *reqmsg)
 452 {
 453     ReplyMsg ((struct Message *)GT_PostFilterIMsg (reqmsg));
 454 }
 455
 456 /****************************************************************************************/
 457
 458 void REGARGS DoScreenToFront (struct Screen *scr, int nopop, int popup)
 459 {
 460     ULONG noscrtofront;
 461
 462     if (nopop) return;
 463
 464     noscrtofront = (rtLockPrefs()->Flags & RTPRF_NOSCRTOFRONT);
 465     rtUnlockPrefs();
 466
 467     if (noscrtofront) return;
 468     if (popup)
 469             ScreenToFront (scr);
 470     else
 471             rtScreenToFrontSafely (scr);
 472 }
 473
 474
 475 /****************************************************************************************/
 476
 477 void REGARGS DoCloseWindow (struct Window *win, int idcmpshared)
 478 {
 479     if (idcmpshared) rtCloseWindowSafely (win);
 480     else CloseWindow (win);
 481 }
 482
 483 /****************************************************************************************/
 484
 485 struct BackFillMsg
 486 {
 487     struct Layer *layer;
 488     struct Rectangle bounds;
 489     LONG offsetx;
 490     LONG offsety;
 491 };
 492
 493 /****************************************************************************************/
 494
 495 #ifdef __AROS__
 496 AROS_UFH3(void, WinBackFill,
 497     AROS_UFHA(struct Hook *, hook, A0),
 498     AROS_UFHA(struct RastPort *, the_rp, A2),
 499     AROS_UFHA(struct BackFillMsg *, msg, A1))
 500 {
 501     AROS_USERFUNC_INIT
 502 #else
 503 void SAVEDS ASM WinBackFill (
 504         REGPARAM(a0, struct Hook *, hook),
 505         REGPARAM(a2, struct RastPort *, the_rp),
 506         REGPARAM(a1, struct BackFillMsg *, msg))
 507 {
 508 #endif
 509     struct RastPort rp;
 510
 511     memcpy( &rp, the_rp, sizeof( rp ) );
 512     rp.Layer = NULL;
 513     SetAPen (&rp, ((UWORD *)hook->h_Data)[BACKGROUNDPEN]);
 514     mySetWriteMask (&rp, ~0);
 515     RectFill (&rp, msg->bounds.MinX, msg->bounds.MinY,
 516                    msg->bounds.MaxX, msg->bounds.MaxY);
 517
 518 #ifdef __AROS__
 519     AROS_USERFUNC_EXIT
 520 #endif
 521 }
 522
 523 /****************************************************************************************/
 524
 525 #ifdef __AROS__
 526
 527 AROS_UFH3(void, PatternWinBackFill,
 528     AROS_UFHA(struct Hook *, hook, A0),
 529     AROS_UFHA(struct RastPort *, the_rp, A2),
 530     AROS_UFHA(struct BackFillMsg *, msg, A1))
 531 {
 532     AROS_USERFUNC_INIT
 533
 534     struct RastPort rp;
 535     UWORD pattern[] = {0xAAAA,0x5555};
 536
 537     memcpy( &rp, the_rp, sizeof( rp ) );
 538     rp.Layer = NULL;
 539
 540     SetAPen (&rp, ((UWORD *)hook->h_Data)[BACKGROUNDPEN]);
 541     SetBPen (&rp, ((UWORD *)hook->h_Data)[SHINEPEN]);
 542     SetDrMd (&rp, JAM2);
 543
 544     mySetWriteMask (&rp, ~0);
 545
 546     SetAfPt(&rp, pattern, 1);
 547
 548     RectFill (&rp, msg->bounds.MinX, msg->bounds.MinY,
 549                    msg->bounds.MaxX, msg->bounds.MaxY);
 550
 551     SetAfPt(&rp, NULL, 0);
 552
 553     AROS_USERFUNC_EXIT
 554 }
 555
 556 #endif
 557
 558 /****************************************************************************************/
 559
 560 void REGARGS mySetWriteMask (struct RastPort *rp, ULONG mask)
 561 {
 562     if (GfxBase->LibNode.lib_Version >= 39) SetWriteMask (rp, mask);
 563     else SetWrMsk (rp, (UBYTE)mask);
 564 }
 565
 566 /****************************************************************************************/
 567
 568 struct Window *REGARGS OpenWindowBF (struct NewWindow *nw,
 569                         struct Hook *hook, UWORD *pens, ULONG *maskptr, WORD *zoom,
 570                         BOOL backfillpattern)
 571 {
 572     struct RastPort *rp;
 573     struct Window *win;
 574     ULONG tags[5], mask;
 575     UWORD maxpen = 0;
 576     int i;
 577
 578 #ifdef __AROS__
 579     if (backfillpattern)
 580     {
 581         hook->h_Entry = (HOOKFUNC)PatternWinBackFill;
 582     } else
 583 #endif
 584     hook->h_Entry = (HOOKFUNC)WinBackFill;
 585
 586     hook->h_Data = (void *)pens;
 587
 588     tags[0] = WA_BackFill;
 589     tags[1] = (ULONG)hook;
 590     tags[2] = WA_Zoom;
 591     tags[3] = (ULONG)zoom;
 592     tags[4] = TAG_END;
 593
 594     if( zoom )
 595     {
 596         if (IntuitionBase->LibNode.lib_Version >= 39)
 597             zoom[0] = zoom[1] = ~0;
 598         else
 599         {
 600             zoom[0] = nw->LeftEdge;
 601             zoom[1] = nw->TopEdge;
 602         }
 603     }
 604     else
 605     {
 606         tags[2] = TAG_IGNORE;
 607     }
 608
 609     if ((win = OpenWindowTagList (nw, (struct TagItem *)tags)))
 610     {
 611         rp = win->RPort;
 612         for (i = 0; i <= HIGHLIGHTTEXTPEN; i++)
 613                 if (pens[i] > maxpen) maxpen = pens[i];
 614
 615         mask = 1;
 616         while (mask < maxpen)
 617         {
 618             mask <<= 1;
 619             mask |= 1;
 620         }
 621
 622         mySetWriteMask (rp, mask);
 623         if (maskptr) *maskptr = mask;
 624     }
 625
 626     return (win);
 627
 628 }
 629
 630 /****************************************************************************************/
 631
 632 int CheckReqPos (int reqpos, int reqdefnum, struct NewWindow *newwin)
 633 {
 634     struct ReqDefaults *reqdefs;
 635
 636     if (reqpos == REQPOS_DEFAULT)
 637     {
 638         reqdefs = &rtLockPrefs()->ReqDefaults[reqdefnum];
 639         reqpos = reqdefs->ReqPos;
 640
 641         if (reqpos <= REQPOS_CENTERSCR)
 642         {
 643             newwin->LeftEdge = 0;
 644             newwin->TopEdge = 0;
 645         }
 646         else
 647         {
 648             newwin->LeftEdge = reqdefs->LeftOffset;
 649             newwin->TopEdge = reqdefs->TopOffset;
 650         }
 651
 652         rtUnlockPrefs();
 653     }
 654
 655     return (reqpos);
 656 }
 657
 658 /****************************************************************************************/
 659
 660 /*********
 661 * Layout *
 662 *********/
 663
 664 /****************************************************************************************/
 665
 666 int REGARGS StrWidth_noloc (struct IntuiText *itxt, UBYTE *str)
 667 {
 668     char labstr[100], *l;
 669
 670     if (!str) return (0);
 671
 672     /* Copy string, remove underscore */
 673     l = labstr;
 674     while (*str && *str != '_') *l++ = *str++;
 675
 676     if (*str) while ((*l++ = *++str)); else *l = 0;
 677
 678     itxt->IText = labstr;
 679
 680     return (IntuiTextLength (itxt));
 681 }
 682
 683 /****************************************************************************************/
 684
 685 static int ObjectWidth (struct NewGadget *ng, int normalw, int normalh)
 686 {
 687     if ((GadToolsBase->lib_Version >= 39) && (ng->ng_TextAttr->ta_YSize > normalh))
 688         return (normalw + (ng->ng_TextAttr->ta_YSize - normalh) * 2);
 689
 690     return (normalw);
 691 }
 692
 693 /****************************************************************************************/
 694
 695 static int ObjectHeight (struct NewGadget *ng, int normalh)
 696 {
 697     if ((GadToolsBase->lib_Version >= 39) && (ng->ng_TextAttr->ta_YSize > normalh))
 698         return (ng->ng_TextAttr->ta_YSize);
 699
 700     return (normalh);
 701 }
 702
 703 /****************************************************************************************/
 704
 705 int CheckBoxWidth (struct NewGadget *ng)
 706 {
 707     return (ObjectWidth (ng, CHECKBOX_WIDTH, CHECKBOX_HEIGHT));
 708 }
 709
 710 /****************************************************************************************/
 711
 712 int CheckBoxHeight (struct NewGadget *ng)
 713 {
 714     return (ObjectHeight (ng, CHECKBOX_HEIGHT));
 715 }
 716
 717 /****************************************************************************************/
 718
 719 /*
 720  * SIZEGAD HEIGHT
 721  */
 722 LONG BottomBorderHeight (struct Screen *scr)
 723 {
 724     struct DrawInfo     *dri;
 725     APTR                obj;
 726     LONG                h = 10;
 727
 728     if ((dri = GetScreenDrawInfo (scr)))
 729     {
 730         if((obj = NewObject (NULL, "sysiclass", SYSIA_DrawInfo, (IPTR) dri,
 731                                                 /* Must be SYSISIZE_MEDRES! */
 732                                                 SYSIA_Size, SYSISIZE_MEDRES,
 733                                                 SYSIA_Which, SIZEIMAGE,
 734                                                 TAG_DONE)))
 735         {
 736             if (!GetAttr (IA_Height, obj, (IPTR *)&h))
 737                     h = 10;  // Probably not needed.. Or?
 738             DisposeObject( obj );
 739         }
 740         FreeScreenDrawInfo (scr, dri);
 741     }
 742     return (h);
 743 }
 744
 745 /****************************************************************************************/